3.93 score from hupso.pl for:
righto.com



HTML Content


Titleken shirriff's blog

Length: 19, Words: 3
Description pusty

Length: 0, Words: 0
Keywords pusty
Robots
Charset UTF-8
Og Meta - Title exist
Og Meta - Description exist
Og Meta - Site name pusty
Tytuł powinien zawierać pomiędzy 10 a 70 znaków (ze spacjami), a mniej niż 12 słów w długości.
Meta opis powinien zawierać pomiędzy 50 a 160 znaków (łącznie ze spacjami), a mniej niż 24 słów w długości.
Kodowanie znaków powinny być określone , UTF-8 jest chyba najlepszy zestaw znaków, aby przejść z powodu UTF-8 jest bardziej międzynarodowy kodowaniem.
Otwarte obiekty wykresu powinny być obecne w stronie internetowej (więcej informacji na temat protokołu OpenGraph: http://ogp.me/)

SEO Content

Words/Characters 13135
Text/HTML 39.29 %
Headings H1 16
H2 24
H3 4
H4 0
H5 0
H6 0
H1
ken shirriff's blog
shift-register counter
inside the stack storage
understanding the die photo
the interface between the stack and the data bus
conclusion
notes and references
inside the 8008 chip
the arithmetic-logic unit
simulating one slice of the alu
understanding the alu logic
instruction decoding: how the alu knows what operation to do
loose ends: subtraction and rotating
history of the 8008
conclusion
notes and references
H2
the 16 boolean logic functions
arithmetic functions
carry lookahead: how to do fast binary addition
creating p and g with an arbitrary boolean function
creating the arithmetic outputs
creating the logic outputs
interactive 74181 viewer
die photo of the 74181 chip.
conclusion
notes and references
a brief guide to npn transistors
inverter
the 74181 schematic
and-or-invert
exclusive-or
not-and
getting the die photos
conclusion
notes and references
popular posts
labels
power supply posts
blog archive
quick links
H3
inside the vintage 74181 alu chip: how it works and why it's so strange
analyzing the vintage 8008 processor from die photos: its unusual counters
reverse-engineering the surprisingly advanced alu of the 8008 microprocessor
inside the 74181 alu chip: die photos and reverse engineering
H4
H5
H6
strong
b
i
em
Bolds strong 0
b 0
i 0
em 0
Zawartość strony internetowej powinno zawierać więcej niż 250 słów, z stopa tekst / kod jest wyższy niż 20%.
Pozycji używać znaczników (h1, h2, h3, ...), aby określić temat sekcji lub ustępów na stronie, ale zwykle, użyj mniej niż 6 dla każdego tagu pozycje zachować swoją stronę zwięzły.
Styl używać silnych i kursywy znaczniki podkreślić swoje słowa kluczowe swojej stronie, ale nie nadużywać (mniej niż 16 silnych tagi i 16 znaczników kursywy)

Statystyki strony

twitter:title pusty
twitter:description pusty
google+ itemprop=name exist
Pliki zewnętrzne 24
Pliki CSS 3
Pliki javascript 21
Plik należy zmniejszyć całkowite odwołanie plików (CSS + JavaScript) do 7-8 maksymalnie.

Linki wewnętrzne i zewnętrzne

Linki 538
Linki wewnętrzne 214
Linki zewnętrzne 324
Linki bez atrybutu Title 443
Linki z atrybutem NOFOLLOW 0
Linki - Użyj atrybutu tytuł dla każdego łącza. Nofollow link jest link, który nie pozwala wyszukiwarkom boty zrealizują są odnośniki no follow. Należy zwracać uwagę na ich użytkowania

Linki wewnętrzne

1 #fn:hackers
2 #fn:carryin
3 #fn:shift
4 #fn:propagate
5 #fn:ls83
6 #fn:order
7 #fn:xor
8 #fn:logictable
9 #fn:credit
7 #fn:xor
10 #fn:outputs
12 #fn:modern
#fnref:hackers
#fnref:carryin
#fnref:shift
#fnref:propagate
#fnref:ls83
#fnref:order
#fnref:xor
#fnref:logictable
#fnref:credit
11 #fn:swapped
#fnref:outputs
#fnref:swapped
#fnref:modern
1 #fn:announcement
2 #fn:shift
3 #fn:numbering
4 #fn:i3101
5 #fn:stacksize
6 #fn:ti
8 #fn:tms1000
7 #fn:lfsr
9 #fn:refresh
11 #fn:t1
10 #fn:inverter
#fnref:announcement
#fnref:shift
#fnref:numbering
#fnref:i3101
#fnref:stacksize
#fnref:ti
#fnref:lfsr
#fnref:tms1000
#fnref:refresh
#fnref:inverter
#fnref:t1
1 #fn:1972
2 #fn:arm
3 #fn:ripple
3 #fn:ripple
6 #fn:acid
5 #fn:pmos
7 #fn:modebits
8 #fn:xor
9 #fn:green
10 #fn:au
11 #fn:fulladder
12 #fn:z80
13 #fn:decode
14 #fn:octal
7 #fn:modebits
15 #fn:alusignals
16 #fn:shifting
2 #fn:arm
17 #fn:inc
#fnref:1972
#fnref:arm
#fnref:ripple
14 #fn:octal
#fnref:ops
#fnref:pmos
#fnref:acid
#fnref:modebits
#fnref:xor
#fnref:green
#fnref:au
#fnref:fulladder
#fnref:z80
#fnref:decode
#fnref:octal
#fnref:alusignals
#fnref:shifting
#fnref:inc
1 #fn:nand
3 #fn:count
4 #fn:history
5 #fn:multiplication
2 #fn:functions
7 #fn:carry
6 #fn:hackers
9 #fn:inverter
11 #fn:r4
10 #fn:schematic7404
12 #fn:diode
13 #fn:credit
8 #fn:implementation
14 #fn:aoi7451
15 #fn:xor
17 #fn:somexor
16 #fn:collectors
#fnref:nand
#fnref:functions
#fnref:count
#fnref:history
#fnref:multiplication
#fnref:hackers
#fnref:carry
#fnref:implementation
#fnref:inverter
#fnref:schematic7404
#fnref:r4
#fnref:diode
#fnref:credit
#fnref:aoi7451
#fnref:xor
#fnref:collectors
#fnref:somexor
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=popularposts&widgetid=popularposts1&action=editwidget§ionid=sidebar-right-1
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=label&widgetid=label1&action=editwidget§ionid=sidebar-right-1
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=adsense&widgetid=adsense1&action=editwidget§ionid=sidebar-right-1
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=linklist&widgetid=linklist2&action=editwidget§ionid=sidebar-right-1
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=html&widgetid=html2&action=editwidget§ionid=sidebar-right-1
▼  javascript:void(0)
▼  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
►  javascript:void(0)
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=blogarchive&widgetid=blogarchive1&action=editwidget§ionid=sidebar-right-1
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=html&widgetid=html1&action=editwidget§ionid=sidebar-right-1
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=linklist&widgetid=linklist1&action=editwidget§ionid=sidebar-right-1
- //www.blogger.com/rearrange?blogid=6264947694886887540&widgettype=attribution&widgetid=attribution1&action=editwidget§ionid=footer-3

Linki zewnętrzne

inside the vintage 74181 alu chip: how it works and why it's so strange http://www.righto.com/2017/03/inside-vintage-74181-alu-chip-how-it.html
full adder circuits https://en.wikipedia.org/wiki/adder_(electronics)#full_adder
- https://lh3.googleusercontent.com/-3rz8utkuv1k/wm6nncwmmhi/aaaaaaaba7k/ejtmjd180_mpkn4xx-uk7iwm_fgyrbnzwchm/w9999/sn74ls181.jpg
superminicomputer https://en.wikipedia.org/wiki/superminicomputer
datasheet http://www.ti.com/product/sn74ls181
- https://lh3.googleusercontent.com/-3cuntuaxmue/wm6nndvpfei/aaaaaaaba7k/_nglbusmslemonv6q0oqte9scasdl5jggchm/w9999/datasheet-74181-operations.png
two's-complement https://en.wikipedia.org/wiki/two%27s_complement
one-bit full adders https://en.wikipedia.org/wiki/adder_(electronics)#full_adder
- https://lh3.googleusercontent.com/-syiwtswaffc/wm6nnyknjhi/aaaaaaaba7k/h_m3cfvl5jspq-wsp8cypbdhssnpvrguwchm/w9999/pg-circuit.jpg
earlier article http://www.righto.com/2017/01/die-photos-and-reverse-engineering.html
- https://lh3.googleusercontent.com/-iki7yd_to78/wg_pyovxj1i/aaaaaaaa_hs/ayuld7wid3ig9bjcihvzqx5uq-sxyka6achm/w9999/74181-die-rot.jpg
kenshirriff https://twitter.com/kenshirriff
apollo181 http://apollo181.wixsite.com/apollo181
fourbit cpu http://jaromir.xf.cz/fourbit/fourbit.html
4 bit ttl cpu https://hackaday.io/project/13017-4-bit-ttl-cpu
magic-1 http://www.homebrewcpu.com/
trex http://www.6502.org/users/dieter/trex/trex.htm
mark 1 forth http://www.aholme.co.uk/mk1/architecture.htm
big mess o' wires http://www.bigmessowires.com/bmow1/
74182 look-ahead carry generator http://www.ti.com/lit/ds/symlink/sn74s182.pdf
74ls83 adder chip http://www.futurlec.com/74ls/74ls83.shtml
diagram by poil on wikimedia https://commons.wikimedia.org/wiki/file:74181aluschematic.png
cc by-sa 3.0 https://creativecommons.org/licenses/by-sa/3.0/deed.en
kogge-stone https://en.wikipedia.org/wiki/kogge%e2%80%93stone_adder
this presentation http://www.cerc.utexas.edu/~jaa/vlsi/lectures/8-1.pdf
this thesis https://repositories.lib.utexas.edu/bitstream/handle/2152/13960/txu-oclc-35052840.pdf
4 comments: https://www.blogger.com/comment.g?blogid=6264947694886887540&postid=9119367631517118431
- https://www.blogger.com/email-post.g?blogid=6264947694886887540&postid=9119367631517118431
- https://www.blogger.com/post-edit.g?blogid=6264947694886887540&postid=9119367631517118431&from=pencil
links to this post http://www.righto.com/2017/03/inside-vintage-74181-alu-chip-how-it.html#links
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=9119367631517118431&target=email
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=9119367631517118431&target=blog
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=9119367631517118431&target=twitter
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=9119367631517118431&target=facebook
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=9119367631517118431&target=pinterest
electronics http://www.righto.com/search/label/electronics
reverse-engineering http://www.righto.com/search/label/reverse-engineering
analyzing the vintage 8008 processor from die photos: its unusual counters http://www.righto.com/2017/03/analyzing-vintage-8008-processor-from.html
- https://lh3.googleusercontent.com/-9v3npsusm8u/wmbkgffzvfi/aaaaaaabar0/_r2bfivp7wclnc91xh0v6fbzqc9jrhd-gchm/w9999/die-stack-block-diagram.jpg
- https://lh3.googleusercontent.com/-kp0jcqz77ee/wmbkgojuo-i/aaaaaaabar0/ega9pemu0iocvctkmpfadox-qmwgaip6wchm/w9999/datapoint-2200-stack.png
4-bit up/down counter chip http://ee-classes.usc.edu/ee459/library/datasheets/dm74ls193.pdf
de bruijn sequence https://en.wikipedia.org/wiki/de_bruijn_sequence
- https://lh3.googleusercontent.com/-xpfhmxlx5ne/wmbkgcorsui/aaaaaaabar0/m9hgt-45smelbo4igukbs3no0qcmptiogchm/w9999/de-bruijn.png
- https://lh3.googleusercontent.com/-jzr8akkpf8k/wmbkgomewyi/aaaaaaabar0/a1drvkq-ma8yygyk5ckxf89niatkdvzmgchm/w9999/stack-counter-schematic.png
- https://lh3.googleusercontent.com/-iilpebusqxe/wmbkgggeazi/aaaaaaabar0/bhjee2n8vkiupn5eyt203ll5oosnt2cdwchm/w9999/stack-cells.png
- https://lh3.googleusercontent.com/-153xh2rd_c0/wmbkgmy3sai/aaaaaaabar0/1_ymi_kya6q-ktqrk4p9lmheae2yobkzwchm/w9999/stack-driver-diagram.jpg
previous article http://www.righto.com/2016/12/die-photos-and-analysis-of_24.html
this article http://www.righto.com/2017/02/reverse-engineering-surprisingly.html
kenshirriff https://twitter.com/kenshirriff
rss feed http://www.righto.com/feeds/posts/default
- https://lh3.googleusercontent.com/-kjlu5lcqpbg/wmbkgpnrfii/aaaaaaabar0/z73tbc93t4ex1btvkkg03slnrbbeibpqachm/w9999/announcement-mar-13.jpg
here http://www.righto.com/2014/12/inside-intel-1405-die-photos-of-shift.html
intel technology journal http://www.intel.com/content/dam/www/public/us/en/documents/research/2001-vol05-iss-1-intel-technology-journal.pdf
7489 http://rtellason.com/chipdata/dm7489.pdf
here http://www.righto.com/2015/05/the-texas-instruments-tmx-1795-first.html
linear-feedback shift registers https://en.wikipedia.org/wiki/linear-feedback_shift_register
the synthesis of nonlinear feedback shift registers http://bitsavers.informatik.uni-stuttgart.de/pdf/stanford/sel_techreports/sel-63-118_the_syntheis_of_nonlinear_feedback_shift_registers_oct63.pdf
counting with nonlinear binary feedback shift registers http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=4037907
shift register sequences https://www.amazon.com/gp/product/0894120484/ref=as_li_tl?ie=utf8&camp=1789&creative=9325&creativeasin=0894120484&linkcode=as2&tag=rightocom&linkid=60098bc8c62df816e39fb81d1703b74d
intel 8008 user's manual http://www.classiccmp.org/8008/8008um.pdf
4 comments: https://www.blogger.com/comment.g?blogid=6264947694886887540&postid=6165577371317526639
- https://www.blogger.com/email-post.g?blogid=6264947694886887540&postid=6165577371317526639
- https://www.blogger.com/post-edit.g?blogid=6264947694886887540&postid=6165577371317526639&from=pencil
links to this post http://www.righto.com/2017/03/analyzing-vintage-8008-processor-from.html#links
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=6165577371317526639&target=email
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=6165577371317526639&target=blog
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=6165577371317526639&target=twitter
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=6165577371317526639&target=facebook
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=6165577371317526639&target=pinterest
8008 http://www.righto.com/search/label/8008
reverse-engineering http://www.righto.com/search/label/reverse-engineering
reverse-engineering the surprisingly advanced alu of the 8008 microprocessor http://www.righto.com/2017/02/reverse-engineering-surprisingly.html
adder circuits https://en.wikipedia.org/wiki/adder_(electronics)
earlier http://www.righto.com/2016/12/die-photos-and-analysis-of_24.html
- https://lh3.googleusercontent.com/-rax2ffk_vls/wjvvcxx4fgi/aaaaaaabaoo/0kqv2hw-5safb6vmsle8qdpgl7rscujfgchm/w9999/die-alu-block-diagram.png
- https://lh3.googleusercontent.com/-pgk-eiaawzu/wjvvcwakgbi/aaaaaaabaoo/w63bmrckxtmubzqsfswopmvmh40yi9doqchm/w9999/die-alu-diagram.png
- https://lh3.googleusercontent.com/-8ej9isavboq/wjvvcd-fy6i/aaaaaaabaoo/dehaqzy6_0ajnlmemo9xtczjvvgklcjfqchm/w9999/alu-die-labeled.png
- https://lh3.googleusercontent.com/-oyi1muowj90/wjvvcyo0dni/aaaaaaabaoo/ugyiltgbg4kwhybqlsi2blsg2dhnebfmwchm/w9999/alu-silicon-labeled.png
previous article http://www.righto.com/2016/12/die-photos-and-analysis-of_24.html
multilevel https://www.tamu.edu/faculty/klbutler/lec6.pdf
full adder https://en.wikipedia.org/wiki/adder_(electronics)#full_adder
- https://lh3.googleusercontent.com/-1fz5y_sa0li/wjvvcs9sxwi/aaaaaaabaoo/xjekhg5zvnolnxne8ikkjgodde2ikwg0wchm/w9999/adder-schematic.png
circuit http://www.intel.com/assets/pdf/general/4004_schematic.pdf
details http://www.righto.com/2013/09/the-z-80-has-4-bit-alu-heres-how-it.html
complex gate arrangement http://www.righto.com/2013/01/inside-alu-of-8085-microprocessor.html
- https://lh3.googleusercontent.com/-qkucdvug-u4/wjvvcxtvbsi/aaaaaaabaoo/je9koxgzwuygozwx9nxnhlq88lhee9zqachm/w9999/decode.png
two's complement arithmetic https://en.wikipedia.org/wiki/two's_complement
ieee spectrum http://spectrum.ieee.org/computing/hardware/the-surprising-story-of-the-first-microprocessors
datapoint 2200 https://en.wikipedia.org/wiki/datapoint_2200
- https://lh3.googleusercontent.com/-1shbetdppw8/wjvvcssipzi/aaaaaaabaoo/yw89_at5vfeqcziiudbmlvjo_gvgcrhpgchm/w9999/2200_brochure.jpg
tmc 1795 http://www.righto.com/2015/05/the-texas-instruments-tmx-1795-first.html
74181 http://www.righto.com/2017/01/die-photos-and-reverse-engineering.html
previous article http://www.righto.com/2016/12/die-photos-and-analysis-of_24.html
kenshirriff https://twitter.com/kenshirriff
rss feed http://www.righto.com/feeds/posts/default
arm-1 http://www.righto.com/2015/12/reverse-engineering-arm1-ancestor-of.html
ripple-carry adder https://en.wikipedia.org/wiki/adder_(electronics)#ripple-carry_adder
manchester carry chain https://en.wikipedia.org/wiki/carry-lookahead_adder#manchester_carry_chain
dynamic logic https://en.wikipedia.org/wiki/dynamic_logic_(digital_electronics)
74181 alu chip http://www.righto.com/2017/01/die-photos-and-reverse-engineering.html
de morgan's laws https://en.wikipedia.org/wiki/de_morgan%27s_laws
full adder circuit https://en.wikipedia.org/wiki/adder_(electronics)#full_adder
de morgan's laws https://en.wikipedia.org/wiki/de_morgan%27s_laws
federico faggin https://en.wikipedia.org/wiki/federico_faggin
programmable logic array https://en.wikipedia.org/wiki/programmable_logic_array
7442 http://www.ti.com/lit/ds/sdls109/sdls109.pdf
x86 http://www.dabo.de/ccc99/www.camp.ccc.de/radio/help.txt
z80 http://www.righto.com/2013/09/the-z-80-has-4-bit-alu-heres-how-it.html
8085 http://www.righto.com/2013/01/inside-alu-of-8085-microprocessor.html
arm-1 http://www.righto.com/2015/12/reverse-engineering-arm1-ancestor-of.html
reference manual http://bitsavers.org/pdf/datapoint/2200/2200_reference_manual.pdf
3 comments: https://www.blogger.com/comment.g?blogid=6264947694886887540&postid=612404970288454532
- https://www.blogger.com/email-post.g?blogid=6264947694886887540&postid=612404970288454532
- https://www.blogger.com/post-edit.g?blogid=6264947694886887540&postid=612404970288454532&from=pencil
links to this post http://www.righto.com/2017/02/reverse-engineering-surprisingly.html#links
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=612404970288454532&target=email
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=612404970288454532&target=blog
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=612404970288454532&target=twitter
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=612404970288454532&target=facebook
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=612404970288454532&target=pinterest
8008 http://www.righto.com/search/label/8008
electronics http://www.righto.com/search/label/electronics
reverse-engineering http://www.righto.com/search/label/reverse-engineering
inside the 74181 alu chip: die photos and reverse engineering http://www.righto.com/2017/01/die-photos-and-reverse-engineering.html
- https://lh3.googleusercontent.com/-iki7yd_to78/wg_pyovxj1i/aaaaaaaa_gc/xlb-vf5onfw5p8zqdg_rqa_zwatcovtnqchm/w9999/74181-die-rot.jpg
- https://lh3.googleusercontent.com/-iyjug7rrtz8/wg_pydprmvi/aaaaaaaa_gc/ipzbsqis_hsf0gmzyxlz5p2apbqr7vorachm/w9999/npn-transistor.jpg
- https://lh3.googleusercontent.com/-yvt-ve_wq7m/wg_pyndyk9i/aaaaaaaa_gc/cswv_sk8nridwtocikzkxbuxytejeksrachm/w9999/inverter-diagram.png
full adder https://en.wikipedia.org/wiki/adder_(electronics)#full_adder
- https://lh3.googleusercontent.com/-hjdccmzwbvg/wg_pyb9k3si/aaaaaaaa_gc/wxhtgbkajr4m6cxsfkee5ugx5kikkznsachm/w9999/schematic-block.png
- https://lh3.googleusercontent.com/-dtclgme36f0/wg_pyb8rzvi/aaaaaaaa_gc/-t0fgqcejpu6crjocdjvjzqtb3kzujprwchm/w9999/die-layout.jpg
and-or-invert https://en.wikipedia.org/wiki/and-or-invert
- https://lh3.googleusercontent.com/-kyzmfp32xg0/wg_pycrydii/aaaaaaaa_gc/mldcfqao_fw4noilzxrzoousnftg4eytgchm/w9999/and-or-invert-diagram2.png
pla https://en.wikipedia.org/wiki/programmable_logic_array
- https://lh3.googleusercontent.com/-n7hnqsaec-i/wg_pylfzhqi/aaaaaaaa_gc/zgwvxrg4uau384zdxec4bsqoovzmewx0qchm/w9999/and-diagram.png
- https://lh3.googleusercontent.com/-hilpmflzzqa/wg_pyeultdi/aaaaaaaa_gc/u8d0umj5ttiiwpcmn_pnv8ums_jq4eccachm/w9999/or-invert-diagram2.png
- https://lh3.googleusercontent.com/-5ajd9q0byb4/whqodbyfebi/aaaaaaaa_iq/6zx8y5ost_guxwdwm9ipdtta5mbmg9-8wchm/w9999/xor-diagram2.png
- https://lh3.googleusercontent.com/-5i_r_2u34w8/wg_pygmfgwi/aaaaaaaa_gc/hjnmrn6kfvyujzcbqamspah-ea2ef9wowchm/w9999/not-and-diagram.png
- https://lh3.googleusercontent.com/-musbvusxvmg/wg_pyilqjdi/aaaaaaaa_gc/qxss5wontdwvshyvw_kjnhgucha_bceeachm/w9999/74181-chip.jpg
- https://lh3.googleusercontent.com/-rxdb8pxx7rq/wg_pyom38li/aaaaaaaa_gc/imv0eamzu_mqldmggdyeizscohqyqngegchm/w9999/74181-opened.jpg
metallurgical microscope http://www.amazon.com/gp/product/b004wmfoy4/ref=as_li_tl?ie=utf8&camp=1789&creative=390957&creativeasin=b004wmfoy4&linkcode=as2&tag=rightocom&linkid=mnrlkeiwaybrwva6
details http://www.righto.com/2015/12/creating-high-resolution-integrated.html
- https://lh3.googleusercontent.com/-rsyherqjsli/wg_pyfakqgi/aaaaaaaa_gc/p9cb5zpws60dszbyeyzf2sta_wzkratvwchm/w9999/74181-die-stripped-rot.jpg
kenshirriff https://twitter.com/kenshirriff
rss feed http://www.righto.com/feeds/posts/default
this site http://apollo181.wixsite.com/apollo181/about
7483 http://www.datasheets360.com/pdf/-6090226736157127018
apollo181 http://apollo181.wixsite.com/apollo181
fourbit cpu http://jaromir.xf.cz/fourbit/fourbit.html
4 bit ttl cpu https://hackaday.io/project/13017-4-bit-ttl-cpu
magic-1 http://www.homebrewcpu.com/
trex http://www.6502.org/users/dieter/trex/trex.htm
mark 1 forth http://www.aholme.co.uk/mk1/architecture.htm
big mess o' wires http://www.bigmessowires.com/bmow1/
74182 look-ahead carry generator http://www.ti.com/lit/ds/symlink/sn74s182.pdf
interdata 7/16 http://bitsavers.informatik.uni-stuttgart.de/pdf/interdata/16bit/7-16/29-364r02_7-16maint_jun74.pdf
carry lookahead https://en.wikipedia.org/wiki/carry-lookahead_adder#carry_lookahead_method
logic gates: the not gate http://www.allaboutcircuits.com/textbook/digital/chpt-3/not-gate/
transistor-transistor logic http://www.csee.wvu.edu/digital/book/chapters/ttl.pdf
this presentation http://uojcourses.awardspace.com/digital%20electronics/ttl%20logic%20family.pptx
7404 inverter chip http://www.ti.com/product/sn7404
diagram by poil on wikimedia https://commons.wikimedia.org/wiki/file:74181aluschematic.png
cc by-sa 3.0 https://creativecommons.org/licenses/by-sa/3.0/deed.en
7451 and-or-invert chip http://www.ti.com/lit/ds/symlink/sn74ls51.pdf
7486 ttl xor chip http://www.interfacebus.com/ic-exclusive-or-gate-dual-input-dip.html
example http://www.ti.com/lit/ds/symlink/sn74ls181.pdf
11 comments: https://www.blogger.com/comment.g?blogid=6264947694886887540&postid=2247786707027740856
- https://www.blogger.com/email-post.g?blogid=6264947694886887540&postid=2247786707027740856
- https://www.blogger.com/post-edit.g?blogid=6264947694886887540&postid=2247786707027740856&from=pencil
links to this post http://www.righto.com/2017/01/die-photos-and-reverse-engineering.html#links
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=2247786707027740856&target=email
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=2247786707027740856&target=blog
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=2247786707027740856&target=twitter
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=2247786707027740856&target=facebook
https://www.blogger.com/share-post.g?blogid=6264947694886887540&postid=2247786707027740856&target=pinterest
electronics http://www.righto.com/search/label/electronics
reverse-engineering http://www.righto.com/search/label/reverse-engineering
older posts http://www.righto.com/search?updated-max=2017-01-06t09:13:00-08:00&max-results=7
home http://www.righto.com/
- http://www.righto.com/2017/03/inside-vintage-74181-alu-chip-how-it.html
inside the vintage 74181 alu chip: how it works and why it's so strange http://www.righto.com/2017/03/inside-vintage-74181-alu-chip-how-it.html
- http://www.righto.com/2017/03/analyzing-vintage-8008-processor-from.html
analyzing the vintage 8008 processor from die photos: its unusual counters http://www.righto.com/2017/03/analyzing-vintage-8008-processor-from.html
- http://www.righto.com/2009/08/multi-protocol-infrared-remote-library.html
a multi-protocol infrared remote library for the arduino http://www.righto.com/2009/08/multi-protocol-infrared-remote-library.html
- http://www.righto.com/2012/10/a-dozen-usb-chargers-in-lab-apple-is.html
a dozen usb chargers in the lab: apple is very good, but not quite the best http://www.righto.com/2012/10/a-dozen-usb-chargers-in-lab-apple-is.html
- http://www.righto.com/2012/05/apple-iphone-charger-teardown-quality.html
apple iphone charger teardown: quality in a tiny expensive package http://www.righto.com/2012/05/apple-iphone-charger-teardown-quality.html
macbook charger teardown: the surprising complexity inside apple's power adapter http://www.righto.com/2015/11/macbook-charger-teardown-surprising.html
- http://www.righto.com/2013/06/teardown-and-exploration-of-magsafe.html
teardown and exploration of apple's magsafe connector http://www.righto.com/2013/06/teardown-and-exploration-of-magsafe.html
- http://www.righto.com/2014/05/a-look-inside-ipad-chargers-pricey.html
ipad charger teardown: inside apple's charger and a risky phony http://www.righto.com/2014/05/a-look-inside-ipad-chargers-pricey.html
6502 http://www.righto.com/search/label/6502
8008 http://www.righto.com/search/label/8008
8085 http://www.righto.com/search/label/8085
alto http://www.righto.com/search/label/alto
apple http://www.righto.com/search/label/apple
arc http://www.righto.com/search/label/arc
arduino http://www.righto.com/search/label/arduino
arm http://www.righto.com/search/label/arm
beaglebone http://www.righto.com/search/label/beaglebone
bitcoin http://www.righto.com/search/label/bitcoin
c# http://www.righto.com/search/label/c%23
calculator http://www.righto.com/search/label/calculator
css http://www.righto.com/search/label/css
electronics http://www.righto.com/search/label/electronics
f# http://www.righto.com/search/label/f%23
fractals http://www.righto.com/search/label/fractals
genome http://www.righto.com/search/label/genome
haskell http://www.righto.com/search/label/haskell
html5 http://www.righto.com/search/label/html5
ibm1401 http://www.righto.com/search/label/ibm1401
ipv6 http://www.righto.com/search/label/ipv6
ir http://www.righto.com/search/label/ir
java http://www.righto.com/search/label/java
javascript http://www.righto.com/search/label/javascript
math http://www.righto.com/search/label/math
oscilloscope http://www.righto.com/search/label/oscilloscope
photo http://www.righto.com/search/label/photo
power supply http://www.righto.com/search/label/power%20supply
random http://www.righto.com/search/label/random
reverse-engineering http://www.righto.com/search/label/reverse-engineering
sheevaplug http://www.righto.com/search/label/sheevaplug
snark http://www.righto.com/search/label/snark
spanish http://www.righto.com/search/label/spanish
teardown http://www.righto.com/search/label/teardown
theory http://www.righto.com/search/label/theory
unicode http://www.righto.com/search/label/unicode
z-80 http://www.righto.com/search/label/z-80
iphone charger teardown http://www.arcfn.com/2012/05/apple-iphone-charger-teardown-quality.html
a dozen usb chargers http://www.arcfn.com/2012/10/a-dozen-usb-chargers-in-lab-apple-is.html
magsafe hacking http://www.righto.com/2013/06/teardown-and-exploration-of-magsafe.html
inside a fake iphone charger http://www.arcfn.com/2012/03/inside-cheap-phone-charger-and-why-you.html
power supply history http://www.arcfn.com/2012/02/apple-didnt-revolutionize-power.html
- http://www.blogger.com/profile/08097301407311055124
2017 http://www.righto.com/search?updated-min=2017-01-01t00:00:00-08:00&updated-max=2018-01-01t00:00:00-08:00&max-results=4
march http://www.righto.com/2017_03_01_archive.html
inside the vintage 74181 alu chip: how it works an... http://www.righto.com/2017/03/inside-vintage-74181-alu-chip-how-it.html
analyzing the vintage 8008 processor from die phot... http://www.righto.com/2017/03/analyzing-vintage-8008-processor-from.html
february http://www.righto.com/2017_02_01_archive.html
january http://www.righto.com/2017_01_01_archive.html
2016 http://www.righto.com/search?updated-min=2016-01-01t00:00:00-08:00&updated-max=2017-01-01t00:00:00-08:00&max-results=34
december http://www.righto.com/2016_12_01_archive.html
october http://www.righto.com/2016_10_01_archive.html
september http://www.righto.com/2016_09_01_archive.html
august http://www.righto.com/2016_08_01_archive.html
july http://www.righto.com/2016_07_01_archive.html
june http://www.righto.com/2016_06_01_archive.html
may http://www.righto.com/2016_05_01_archive.html
april http://www.righto.com/2016_04_01_archive.html
march http://www.righto.com/2016_03_01_archive.html
february http://www.righto.com/2016_02_01_archive.html
january http://www.righto.com/2016_01_01_archive.html
2015 http://www.righto.com/search?updated-min=2015-01-01t00:00:00-08:00&updated-max=2016-01-01t00:00:00-08:00&max-results=12
december http://www.righto.com/2015_12_01_archive.html
november http://www.righto.com/2015_11_01_archive.html
october http://www.righto.com/2015_10_01_archive.html
august http://www.righto.com/2015_08_01_archive.html
may http://www.righto.com/2015_05_01_archive.html
march http://www.righto.com/2015_03_01_archive.html
february http://www.righto.com/2015_02_01_archive.html
2014 http://www.righto.com/search?updated-min=2014-01-01t00:00:00-08:00&updated-max=2015-01-01t00:00:00-08:00&max-results=13
december http://www.righto.com/2014_12_01_archive.html
october http://www.righto.com/2014_10_01_archive.html
september http://www.righto.com/2014_09_01_archive.html
may http://www.righto.com/2014_05_01_archive.html
march http://www.righto.com/2014_03_01_archive.html
february http://www.righto.com/2014_02_01_archive.html
2013 http://www.righto.com/search?updated-min=2013-01-01t00:00:00-08:00&updated-max=2014-01-01t00:00:00-08:00&max-results=24
november http://www.righto.com/2013_11_01_archive.html
september http://www.righto.com/2013_09_01_archive.html
august http://www.righto.com/2013_08_01_archive.html
july http://www.righto.com/2013_07_01_archive.html
june http://www.righto.com/2013_06_01_archive.html
april http://www.righto.com/2013_04_01_archive.html
march http://www.righto.com/2013_03_01_archive.html
february http://www.righto.com/2013_02_01_archive.html
january http://www.righto.com/2013_01_01_archive.html
2012 http://www.righto.com/search?updated-min=2012-01-01t00:00:00-08:00&updated-max=2013-01-01t00:00:00-08:00&max-results=10
december http://www.righto.com/2012_12_01_archive.html
november http://www.righto.com/2012_11_01_archive.html
october http://www.righto.com/2012_10_01_archive.html
may http://www.righto.com/2012_05_01_archive.html
march http://www.righto.com/2012_03_01_archive.html
february http://www.righto.com/2012_02_01_archive.html
2011 http://www.righto.com/search?updated-min=2011-01-01t00:00:00-08:00&updated-max=2012-01-01t00:00:00-08:00&max-results=11
december http://www.righto.com/2011_12_01_archive.html
july http://www.righto.com/2011_07_01_archive.html
may http://www.righto.com/2011_05_01_archive.html
april http://www.righto.com/2011_04_01_archive.html
march http://www.righto.com/2011_03_01_archive.html
february http://www.righto.com/2011_02_01_archive.html
2010 http://www.righto.com/search?updated-min=2010-01-01t00:00:00-08:00&updated-max=2011-01-01t00:00:00-08:00&max-results=22
december http://www.righto.com/2010_12_01_archive.html
november http://www.righto.com/2010_11_01_archive.html
october http://www.righto.com/2010_10_01_archive.html
august http://www.righto.com/2010_08_01_archive.html
june http://www.righto.com/2010_06_01_archive.html
may http://www.righto.com/2010_05_01_archive.html
april http://www.righto.com/2010_04_01_archive.html
march http://www.righto.com/2010_03_01_archive.html
january http://www.righto.com/2010_01_01_archive.html
2009 http://www.righto.com/search?updated-min=2009-01-01t00:00:00-08:00&updated-max=2010-01-01t00:00:00-08:00&max-results=22
december http://www.righto.com/2009_12_01_archive.html
november http://www.righto.com/2009_11_01_archive.html
september http://www.righto.com/2009_09_01_archive.html
august http://www.righto.com/2009_08_01_archive.html
july http://www.righto.com/2009_07_01_archive.html
june http://www.righto.com/2009_06_01_archive.html
april http://www.righto.com/2009_04_01_archive.html
march http://www.righto.com/2009_03_01_archive.html
february http://www.righto.com/2009_02_01_archive.html
january http://www.righto.com/2009_01_01_archive.html
2008 http://www.righto.com/search?updated-min=2008-01-01t00:00:00-08:00&updated-max=2009-01-01t00:00:00-08:00&max-results=27
july http://www.righto.com/2008_07_01_archive.html
june http://www.righto.com/2008_06_01_archive.html
may http://www.righto.com/2008_05_01_archive.html
april http://www.righto.com/2008_04_01_archive.html
march http://www.righto.com/2008_03_01_archive.html
february http://www.righto.com/2008_02_01_archive.html
arduino ir library http://www.arcfn.com/2009/08/multi-protocol-infrared-remote-library.html
6502 reverse-engineering http://www.righto.com/2013/01/a-small-part-of-6502-chip-explained.html
blogger https://www.blogger.com

Zdjęcia

Zdjęcia 56
Zdjęcia bez atrybutu ALT 25
Zdjęcia bez atrybutu TITLE 25
Korzystanie Obraz ALT i TITLE atrybutu dla każdego obrazu.

Zdjęcia bez atrybutu TITLE

http://img1.blogblog.com/img/icon18_email.gif
https://resources.blogblog.com/img/icon18_edit_allbkg.gif
http://img1.blogblog.com/img/icon18_email.gif
https://resources.blogblog.com/img/icon18_edit_allbkg.gif
http://img1.blogblog.com/img/icon18_email.gif
https://resources.blogblog.com/img/icon18_edit_allbkg.gif
http://img1.blogblog.com/img/icon18_email.gif
https://resources.blogblog.com/img/icon18_edit_allbkg.gif
https://lh3.googleusercontent.com/-3rz8utkuv1k/wm6nncwmmhi/aaaaaaaba7k/ejtmjd180_mpkn4xx-uk7iwm_fgyrbnzwchm/w72-h72-p-k-no-nu/sn74ls181.jpg
https://lh3.googleusercontent.com/-9v3npsusm8u/wmbkgffzvfi/aaaaaaabar0/_r2bfivp7wclnc91xh0v6fbzqc9jrhd-gchm/w72-h72-p-k-no-nu/die-stack-block-diagram.jpg
https://lh6.googleusercontent.com/proxy/domxe8hosryuthphgvatf3nqzgsasi0udl52iuxown6by7bruv6kfahs5cg823xpgm1mlrbzoex7lv-eul1oy9u3=w72-h72-p-k-no-nu
https://lh5.googleusercontent.com/proxy/9re--hj9_-jqorikgafsru5z3xebyln9jl7awgx7tntx37uj4f1nw9hqpw6c8ce9q01nad4ytwskn1dqd6xatsrfuzmeat1eohx-tyd3=w72-h72-p-k-no-nu
https://lh5.googleusercontent.com/proxy/h1kk6zd8ytuoru6h6x6qkdn1hf_ikbh_jkquqhjuhtizy9694oxxr7vtgwhgln476qz5ihsole_cbq2nhufhjyhoslbszvxbivr6bwzwmnz5dbgyh0jq=w72-h72-p-k-no-nu
https://lh6.googleusercontent.com/proxy/1ib2k6sjs0_hawylqzxups-wtrvepycouijc87mcikmpi8w-4mk2btliwo1lnaklwrqmcxtgztn6-xihrp83umnsx51efbocu10rot78ap7_gye1=w72-h72-p-k-no-nu
https://lh3.googleusercontent.com/proxy/chbyq4dmix8sfubgh649lxan58cdzxfmbfqbiy3ubqufiuurogqugo-ckyat3cgltd9lcb7_prgbhmkonaig4mz8s45nqazznumqhrq2odk4sto=w72-h72-p-k-no-nu
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://lh4.googleusercontent.com/-4ne0tsewmu8/t7-1iacgxbi/aaaaaaaakpo/buaz-b76cv4/s800/name.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png

Zdjęcia bez atrybutu ALT

http://img1.blogblog.com/img/icon18_email.gif
https://resources.blogblog.com/img/icon18_edit_allbkg.gif
http://img1.blogblog.com/img/icon18_email.gif
https://resources.blogblog.com/img/icon18_edit_allbkg.gif
http://img1.blogblog.com/img/icon18_email.gif
https://resources.blogblog.com/img/icon18_edit_allbkg.gif
http://img1.blogblog.com/img/icon18_email.gif
https://resources.blogblog.com/img/icon18_edit_allbkg.gif
https://lh3.googleusercontent.com/-3rz8utkuv1k/wm6nncwmmhi/aaaaaaaba7k/ejtmjd180_mpkn4xx-uk7iwm_fgyrbnzwchm/w72-h72-p-k-no-nu/sn74ls181.jpg
https://lh3.googleusercontent.com/-9v3npsusm8u/wmbkgffzvfi/aaaaaaabar0/_r2bfivp7wclnc91xh0v6fbzqc9jrhd-gchm/w72-h72-p-k-no-nu/die-stack-block-diagram.jpg
https://lh6.googleusercontent.com/proxy/domxe8hosryuthphgvatf3nqzgsasi0udl52iuxown6by7bruv6kfahs5cg823xpgm1mlrbzoex7lv-eul1oy9u3=w72-h72-p-k-no-nu
https://lh5.googleusercontent.com/proxy/9re--hj9_-jqorikgafsru5z3xebyln9jl7awgx7tntx37uj4f1nw9hqpw6c8ce9q01nad4ytwskn1dqd6xatsrfuzmeat1eohx-tyd3=w72-h72-p-k-no-nu
https://lh5.googleusercontent.com/proxy/h1kk6zd8ytuoru6h6x6qkdn1hf_ikbh_jkquqhjuhtizy9694oxxr7vtgwhgln476qz5ihsole_cbq2nhufhjyhoslbszvxbivr6bwzwmnz5dbgyh0jq=w72-h72-p-k-no-nu
https://lh6.googleusercontent.com/proxy/1ib2k6sjs0_hawylqzxups-wtrvepycouijc87mcikmpi8w-4mk2btliwo1lnaklwrqmcxtgztn6-xihrp83umnsx51efbocu10rot78ap7_gye1=w72-h72-p-k-no-nu
https://lh3.googleusercontent.com/proxy/chbyq4dmix8sfubgh649lxan58cdzxfmbfqbiy3ubqufiuurogqugo-ckyat3cgltd9lcb7_prgbhmkonaig4mz8s45nqazznumqhrq2odk4sto=w72-h72-p-k-no-nu
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://lh4.googleusercontent.com/-4ne0tsewmu8/t7-1iacgxbi/aaaaaaaakpo/buaz-b76cv4/s800/name.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png
https://resources.blogblog.com/img/icon18_wrench_allbkg.png

Ranking:


Alexa Traffic
Daily Global Rank Trend
Daily Reach (Percent)









Majestic SEO











Text on page:

ken shirriff's blog chargers, microprocessors, arduino, and whatever inside the vintage 74181 alu chip: how it works and why it's so strange the 74181 alu (arithmetic/logic unit) chip powered many of the minicomputers of the 1970s: it provided fast 4-bit arithmetic and logic functions, and could be combined to handle larger words, making it a key part of many cpus. but if you look at the chip more closely, there are a few mysteries. it implements addition, subtraction, and the boolean functions you'd expect, but why does it provide several bizarre functions such as "a plus (a and not b)"? and if you look at the circuit diagram (below), why does it look like a random pile of gates rather than being built from standard full adder circuits. in this article, i explain that the 74181's set of functions isn't arbitrary but has a logical explanation. and i show how the 74181 implements carry lookahead for high speed, resulting in its complex gate structure. schematic of the 74ls181 alu chip, from the datasheet. the internal structure of the chip is surprisingly complex and difficult to understand at first. the 74181 chip is important because of its key role in minicomputer history. before the microprocessor era, minicomputers built their processors from boards of individual chips. a key part of the processor was the arithmetic/logic unit (alu), which performed arithmetic operations (addition, subtraction) and logical operations (and, or, xor). early minicomputers built alus out of a large number of simple gates. but in march 1970, texas instruments introduced the 74181 arithmetic / logic unit (alu) chip, which put a full 4-bit alu on one fast ttl chip. this chip provided 32 arithmetic and logic functions, as well as carry lookahead for high performance. using the 74181 chip simplified the design of a minicomputer processor and made it more compact, so it was used in many minicomputers. computers using the 74181 ranged from the popular pdp-11 and xerox alto minicomputers to the powerful vax-11/780 "superminicomputer". the 74181 is still used today in retro hacker projects.1 the 74181 implements a 4-bit alu providing 16 logic functions and 16 arithmetic functions, as the datasheet (below) shows. as well as the expected addition, subtraction, and boolean operations, there are some bizarre functions such as "(a + b) plus ab". the datasheet for the 74181 alu chip shows a strange variety of operations. so how is the 74181 implemented and why does it include such strange operations? is there any reason behind the 74181's operations, or did they just randomly throw things in? and why are the logic functions and arithmetic functions in any particular row apparently unrelated? i investigated the chip to find out. the 16 boolean logic functions there's actually a system behind the 74181's set of functions: the logic functions are the 16 possible boolean functions f(a,b). why are there 16 possible functions? if you have a boolean function f(a,b) on one-bit inputs, there are 4 rows in the truth table. each row can output 0 or 1. so there are 2^4 = 16 possible functions. extend these to 4 bits, and these are exactly the 16 logic functions of the 74181, from trivial 0 and 1 to expected logic like a and b to contrived operations like not a and b. these 16 functions are selected by the s0-s3 select inputs. arithmetic functions the 74181's arithmetic operations are a combination of addition, subtraction, logic operations, and strange combinations such as "a plus ab plus 1". it turns out that there is a rational system behind the operation set: they are simply the 16 logic functions added to a along with the carry-in.2 that is, the arithmetic functions are: a plus f(a,b) plus carry-in. for example, if f(a,b)=b, you get simple addition: a plus b plus carry-in. if f(a,b) = not b, you get a plus not b plus carry-in, which in two's-complement logic turns into subtraction: a minus b minus 1 plus carry-in. other arithmetic functions take a bit more analysis. suppose f(a,b) = not (a or b). then each bit of a plus f(a,b) will always be 1 except in the case where a is 0 and b is 1, so the result of the sum is a or not b. even though you're doing addition, the result is a logical function since no carry can be generated. the other strange arithmetic functions can be understood similarly.3 thus, the 16 arithmetic functions of the 74181 are a consequence of combining addition with one of the 16 boolean functions. even though many of the functions are strange and probably useless, there's a reason for them. (the boolean logic functions for arithmetic are in a different order than for logical operations, explaining why there's no obvious connection between the arithmetic and logical functions.) carry lookahead: how to do fast binary addition the straightforward but slow way to build an adder is to use a simple one-bit full adders for each bit, with the carry out of one adder going into the next adder. the result is kind of like doing long addition by hand: in decimal if you add 9999 + 1, you have to carry the 1 from each column to the next, which is slow. this "ripple carry" makes addition a serial operation instead of a parallel operation, harming the processor's performance. to avoid this, the 74181 computes the carries first and then adds all four bits in parallel, avoiding the delay of ripple carry. this may seem impossible: how can you determine if there's a carry before you do the addition? the answer is carry lookahead. carry lookahead uses "generate" and "propagate" signals to determine if each bit position will always generate a carry or can potentially generate a carry. for instance, if you're adding 0+0+c (where c is the carry-in), there's no way to get a carry out from that addition, regardless of what c is. on the other hand, if you're adding 1+1+c, there will always be a carry out generated, regardless of c. this is called the generate case. finally, for 0+1+c (or 1+0+c), there will be a carry out if there is a carry in. this is called the propagate case since if there is a carry-in, it is propagated to the carry out.4 putting this all together, for each bit position you create a g (generate) signal if both bits are 1, and a p (propagate) signal unless both bits are 0. the carry from each bit position can be computed from the p and g signals by determining which combinations can produce a carry. for instance, there will be a carry from bit 0 to bit 1 if p0 is set (i.e. a carry is generated or propagated) and there is either a carry-in or a generated carry. so c1 = p0 and (cin or g0). higher-order carries have more cases and are progressively more complicated. for example, consider the carry in to bit 2. first, p1 must be set for a carry out from bit 1. in addition, a carry either was generated by bit 1 or propagated from bit 0. finally, the first carry must have come from somewhere: either carry-in, generated from bit 0 or generated from bit 1. putting this all together produces the function used by the 74181: c2 = p1 and (g1 or p0) and (c0 or g0 or g1). as you can see, the carry logic gets more complicated for higher-order bits, but the point is that each carry can be computed from g and p terms and the carry-in. thus, the carries can be computed in parallel, before the addition takes place.5 creating p and g with an arbitrary boolean function the previous section showed how the p (propagate) and g (generate) signals can be used when adding two values. the next step is to examine how p and g are created when adding an arbitrary boolean function f(a, b), as in the 74181. the table below shows p and g when computing "a plus f(a,b)". for instance, when a=0 there can't be a generate, and propagate depends on the value of f. and when a=1, there must be a propagate, while generate depends on the value of f. a b a plus f(a,b) p g 0 0 0+f(0,0) f(0,0) 0 0 1 0+f(0,1) f(0,1) 0 1 0 1+f(1,0) 1 f(1,0) 1 1 1+f(1,1) 1 f(1,1) in the 74181, the four f values are supplied directly by the four select (s pin) values, resulting in the following table:6 a b a plus f p g 0 0 0 s1 0 0 1 1 s0 0 1 0 1 1 s2 1 1 10 1 s3 the chip uses the logic block below (repeated four times) to compute p and g for each bit. it is straightforward to verify that it implements the table above. for instance, g will be set if a is 1, b is 1 and s3 is 1, or if a is 1, b is 0 and s2 is set. this circuit computes the g (generate) and p (propagate) signals for each bit of the 74181 alu chip's sum. the s0-s3 selection lines select which function is added to a. creating the arithmetic outputs the addition outputs are generated from the internal carries (c0 through c3), combined with the p and g signals. for each bit, a plus f is the same as p ⊕ g, so adding in the carry gives us the full 4-bit sum. thus, f0 = c0 ⊕ p0 ⊕ g0, and similarly for the other f outputs.7 on the schematic, each output bit has two xor gates for this computation. creating the logic outputs for the logic operations, the carries are disabled by forcing them all to 1. to select a logic operation, the m input is set to 1. m is fed into all the carry computation's and-nor gates, forcing the carries to 1. the output bit sum as as above, producing a ⊕ f ⊕ 1 = a ⊕ f. this expression yields all 16 boolean functions, but in a scrambled order relative to the arithmetic functions.8 interactive 74181 viewer to see how the circuits of the 74181 work together, try the interactive schematic below.9 the chip's inputs are along the top and right; click on any of them to change the value. the a and b signals are the two 4-bit arguments. the s bits on the right select the operation. c is the carry-in (which is inverted). m is the mode, 0 for logic operations and 1 for arithmetic operations. the dynamic chart under the schematic describes what operation is being performed. the p and g signals are generated by the top part of the circuitry, as described above. below this, the carry lookahead logic creates the carry (c) signals by combining the p and g signals with the carry-in (cn). finally, the sum for each bit is generated (σ) from the p and g signals7, then combined with each carry to generate the f outputs in parallel.10 result and truth table for inputs entered above select : 0000 a 0000 b 0001 f 1001 ai bi pi gi fi 0 0 x y f 0 1 x y f 1 0 x y f 1 1 x y f die photo of the 74181 chip. i opened up a 74181, took die photos, and reverse engineered its ttl circuitry. my earlier article discusses the circuitry in detail, but i'll include a die photo here since it's a pretty chip. (click image for full size.) around the edges you can see the thin bond wires that connect the pads on the die to the external pins. the shiny golden regions are the metal layer, providing the chip's internal wiring. underneath the metal, the purplish silicon is doped to form the transistors and resistors of the ttl circuits. the die layout closely matches the simulator schematic above, with inputs at the top and outputs at the bottom. die photo of the 74181 alu chip. the metal layer of the die is visible; the silicon (forming transistors and resistors) is hidden behind it. conclusion while the 74181 appears at first to be a bunch of gates randomly thrown together to yield bizarre functions, studying it shows that there is a system to its function set: it provides all 16 boolean logic functions, as well as addition to these functions. the circuitry is designed around carry lookahead, generating g and p signals, so the result can be produced in parallel without waiting for carry propagation. modern processors continue to use carry lookahead, but in more complex forms optimized for long words and efficient chip layout.12 i announce my latest blog posts on twitter, so follow me at kenshirriff. notes and references retro projects using the 74181 include the apollo181 cpu, fourbit cpu, 4 bit ttl cpu, magic-1 (using the 74f381), trex, mark 1 forth and big mess o' wires. ↩ the carry-in input and the carry-out output let you chain together multiple 74181 chips to add longer words. the simple solution is to ripple the carry from one chip to the next, and many minicomputers used this approach. a faster technique is to use a chip, the 74182 look-ahead carry generator, that performs carry lookahead across multiple 74181 chips, allowing them to all work in parallel. ↩ one thing to note is a plus a gives you left shift, but there's no way to do right shift on the 74181 without additional circuitry. ↩ to simplify the logic, the 74181 considers 1+1+c both a propagate case and a generate case. (some carry lookahead systems consider 1+1+c to be a propgate case but not a generate case.) for the 74181's outputs, propagate must be set for generate to be meaningful. ↩ the carry-lookahead logic in the 74181 is almost identical to the earlier 74ls83 adder chip. the 74181's circuitry can be viewed as an extension of the 74ls83 to support 16 boolean functions and to support logical functions by disabling the carry. ↩ the way the s0 and s1 values appear in the truth table seems backwards to me, but that's how the chip works. ↩ the bit sum σ can be easily produced from the p and g signals. some datasheets show each σ signal generated as p xor g, while other datasheets show σ generated as not p and g. since the combination p=0, g=1 never arises, both generate the same results. i show xor on the schematic as it is conceptually easier to understand, but examining the die shows the physical circuit uses the not/and gates. ↩ the logic functions are defined in terms of select inputs as follows: a b f 0 0 s1 0 0 s0 0 0 s2 0 0 s3 because the first two terms are inverted, the logic function for a particular select input doesn't match the arithmetic function. ↩ the schematic is based on a diagram by poil on wikimedia, cc by-sa 3.0, with circuitry and labeling changes. ↩ the 74181 chip has a few additional outputs. the a=b output is used with the subtraction operation to test the two inputs for equality. the cn+4 output is the inverted carry out, supporting longer words. p and g are the carry propagate and generate outputs, used for carry lookahead with longer words.11 ↩ the p and g outputs in my schematic are reversed compared to the datasheet, for slightly complicated reasons. i'm describing the 74181 with active-high logic, where a high signal indicates 1, as you'd expect. however, the 74181 can also be used with active-low logic, where a low signal indicates a 1. the 74181 works fine with active-low logic except the meanings of some pins change, and the operations are shuffled around. the p and g labels on the datasheet are for active-low logic, so with active-high, they are reversed. ↩ one example of a modern carry lookahead adder is kogge-stone. see this presentation for more information on modern adders, or this thesis for extensive details. ↩ 4 comments: links to this post email thisblogthis!share to twittershare to facebookshare to pinterest labels: electronics, reverse-engineering analyzing the vintage 8008 processor from die photos: its unusual counters the revolutionary intel 8008 microprocessor is 45 years old today (march 13, 2017), so i figured it's time for a blog post on reverse-engineering its internal circuits. one of the interesting things about old computers is how they implemented things in unexpected ways, and the 8008 is no exception. compared to modern architectures, one unusual feature of the 8008 is it had an on-chip stack for subroutine calls, rather than storing the stack in ram. and instead of using normal binary counters for the stack, the 8008 saved a few gates by using shift-register counters that generated pseudo-random values. in this article, i reverse-engineer these circuits from die photos and explain how they work. the image below shows the 8008's tiny silicon die, highly magnified. around the outside of the die, you can see the 18 wires connecting the die to the chip's external pins. the 8008's circuitry is built from about 3500 tiny transistors (yellow) connected by a metal wiring layer (white). this article will focus on the stack circuits on the right side of the chip and how they interact with the data bus (blue). the die of the intel 8008 microprocessor, showing the stack and other important subcomponents. for the 8008 processor's birthday, i'm using the date of its first public announcement, an article in electronics on march 13, 1972 entitled "8-bit parallel processor offered on a single chip." this article described the 8008 as a complete central processing unit for use in "intelligent terminals" and stated that chips were available at $200 each.1 you might think that an intelligent terminal is a curiously specific application for the 8008 processor. there's an interesting story behind that, going back to the roots of the chip: the datapoint 2200 "programmable terminal", introduced in june 1970. the popular datapoint 2200 was essentially a desktop minicomputer with its processor consisting of a board full of simple ttl chips. the photo below shows the cpu board from the datapoint 2200. the chips are gates, flip flops, decoders, and so forth, combined to build a processor, since microprocessors didn't exist at the time. the processor board from the datapoint 2200. the 8008 microprocessor was created to replace this board, but was never used by datapoint. photo courtesy of unknown source. processors typically use a stack to store addresses for subroutine calls, so they can "pop" the return address off the stack. this stack is usually stored in main memory. however, the datapoint 2200 used slow shift-register memory2 instead of expensive ram for its main storage, so implementing a stack in main memory would be slow and inconvenient. instead, the datapoint 2200's stack was stored in four i3101 ram chips, providing a small stack of 16 entries. 3 4 the i3101 was intel's very first product, and held just 64 bits. in the photo above, you can see the chips in their distinctive white packaging each with a large "i" for intel. 5 to keep track of the top of the stack, the datapoint 2200 used a 4-bit up/down counter chip to hold the stack pointer. the clever thing about this design is there's no separate program counter (pc) and stack; the pc is simply the value at the top of the stack. you don't need to explicitly push and pop the pc onto the stack; for a subroutine call you just update the counter and write the subroutine address to the stack. the story of the 8008's origin is that datapoint went to intel and asked if intel could build a chip that combined the stack memory and the stack pointer onto a single chip. intel said not only could they do that, they could put the whole processor board onto a single chip! this was the start of intel's 8008 project to duplicate the datapoint 2200's processor board onto a chip, keeping the datapoint 2200 instruction set and architecture.6 after various delays, intel completed the 8008 microprocessor, but datapoint rejected it. intel decided to sell the 8008 as a general-purpose processor chip, sparking the microprocessor revolution. intel improved the 8008 with the 8080 and then the 16-bit 8086, leading to the x86 architecture that dominates desktop and server computers today. the consequence of the 8008's history is that it inherited its architecture and instruction set from the datapoint 2200 intelligent terminal. one of these features was the fixed, internal stack. but the 8008's implementation of that stack is unusual. shift-register counter the most unexpected part of the 8008's stack is how it keeps track of the current position. the straightforward way to implement the stack would be with a binary up/down counter to keep track of the current stack position (which is what the datapoint 2200 did). but to save a few transistors, the 8008 uses a nonlinear feedback shift register instead of a counter. the result is the stack entries are accessed in a pseudo-random order! but since they are read and written in the same order, everything works out fine. the shift register outputs are based on a de bruijn sequence, a cyclic sequence in which every possible output occurs as a subsequence exactly once. the 8008's de bruijn sequence is shown below. the first value (000) is underlined in red. shifting to the blue position yields the second value (001). proceeding around the circle clockwise yields all eight values in the sequence: 000, 001, 010, 101, 011, 111, 110, 100 and finally back to 000. note that each value appears exactly once, but they are not in standard binary order. 8this de bruijn sequence contains all eight 3-bit values as subsequences. 000 and 001 are underlined. the intel 8008's internal counters are built form this sequence. at each step in the sequence, the last two bits are shifted to the left and a new bit is placed on the right. counting down is the converse: the first two bits are shifted to the right and a new bit is placed one the left. this process can be implemented with a shift register, a circuit that allows a bit sequence to be shifted and an additional bit inserted.7 the diagram below shows how the 8008 implements the nonlinear feedback shift register counter. while it make look complex, it's a straightforward implementation of the de bruijn sequence. the three latches in the middle form a shift register, with each latch holding one bit. to count up, each bit is shifted to the left and a new bit is added on the right (green arrows). to count down, each bit is shifted to the right and a new bit is added on the left (purple arrows). the logic gate on the left generate the "new" bit for counting down and the gates on the right generate the new bit for counting up. the 8008 uses the above circuit for its internal stack counter. the refresh counter is based on this, but counts up only. the logic gates may appear complex. however, one feature of pmos logic is it's as simple to build an and-or-nor gate as a plain nor gate, just by wiring transistors in parallel or series. designing the logic is also straightforward: for each triple of current bits, the de bruijn sequence specifies the next bit. if you've studied digital logic, karnaugh maps can be used to create the logic circuits to generate the desired next bit. inside the stack storage the 8008 uses dynamic ram (dram) to for its stack storage and its registers. the other 1970s microprocessors that i've examined use static latches, so the 8008 is a bit unusual in this regard. since intel was primarily a ram company at the time, i assume they wanted to leverage their ram skills and save transistors by using dram. each bit of storage in the 8008 uses a cell with three transistors and one capacitors, called a 3t1c cell, similar to the cell in intel's i1103 dram chip. the diagram below shows a closeup of the 8008's stack storage, with six dram cells visible. each row is one 14-bit address in the stack. each row has a read enable and write enable control line coming from the left. each column stores one of the 14 bits; the column sense line is used to read and write the selected bit. detail of the intel 8008 microprocessor's die, showing six storage cells for the stack registers. each bit is stored with a dram cell consisting of three transistors and a capacitor. the transistors for the first cell are labeled t1, t2 and t3. the value is stored on the capacitor labeled c. (there is no separate physical capacitor; the capacitance of the wiring is sufficient to store the bit.) to write a bit, the write line for the desired row is pulled low, turning on t1. the desired voltage (low or high) is fed onto the sense line, passes through t1, and is stored by the capacitor. to read the value, the appropriate read line is pulled low, turning on t3. if c has a low voltage, t2 is turned on. this connects the sense line to ground through t3 and t2. on the other hand, if c has a high voltage, t2 is turned off and the sense line is not grounded. thus, the circuitry connected to the sense line can tell what bit value is stored on c. the inconvenience with dynamic ram is that values can only be stored temporarily. after a few hundred microseconds, the charge stored on capacitor c will leak away and the value will be lost. the solution is a refresh circuit that periodically reads each value and writes it back, before the bit fades away. (a similar refresh process is used by your computer's ram.) the 8008's internal ram is refreshed at least every 240 microseconds, ensuring that bits are not lost. (static ram, on the other hand, uses a larger, more complex circuit for each bit, but will preserve the bit as long as the circuit is powered up.) in the 8008, the stack storage (and the registers) are refreshed by continuously stepping through each entry: reading it and writing it back. to accomplish this, a second 3-bit shift-register counter is used as a refresh counter, tracking the current position that is being refreshed. the circuit for this is the same as the stack counter, except it omits the logic to count down, as it only needs to count in one direction.9 understanding the die photo i'll briefly explain what you're looking at in the die photo above. the chip itself is made from a silicon wafer. plain silicon is essentially an insulator, but by doping it with impurities, it becomes a semiconductor. the dark lines indicate the boundary between doped and undoped regions; the doped silicon in the first cell is indicated in red. on top of the silicon is the polysilicon layer, which is the yellowish stripes. polysilicon acts as a conductor and is used as internal wiring of the chip. more importantly, a transistor is created when polysilicon crosses doped silicon. a thin oxide layer separates the polysilicon from the silicon, forming the transistor's gate. a low voltage on the polysilicon gate causes the transistor to conduct, connecting the two sides (called source and drain) of the transistor. a high voltage on the gate turns the transistor off, disconnecting the two sides. thus, the transistor acts as a switch, controlled by the gate. the top layer of the chip is the metal layer, which is also used as wiring. for the photo above, i removed the metal layer with hydrochloric acid to make the underlying silicon more visible. the green, blue and gray lines indicate where the metal wiring was before being removed. transistors t1 and t3 are connected to the sense line (blue), while transistor t2 is connected to ground (green). the read and write lines enter the circuit on the left as metal wiring, connected to polysilicon lines. the interface between the stack and the data bus to access memory, the address in the stack must be provided to external memory via the 8 data/address pins on the chip. these pins are connected to the stack (and other parts of the 8008) via the data bus. the die photo below shows the circuitry that interfaces the 14-bit stack storage to the 8-bit data bus.11 at the top of the photo are the metal control lines and three of the data bus lines. at the bottom are the sense lines, discussed earlier, from the stack storage. in between are the transistors (orange) that connect the data bus and the stack. the control lines select the low (l) or high (h) half of the address. these activate the appropriate read or write transistors, connecting the appropriate stack columns to the data bus. the stack /bus driver circuit provides the "glue" between the data bus and the stack dram storage. the transistors to write an address to the data bus are much larger than typical transistors, appearing as vertical yellow bars in the die photo. the reason for this is the data bus passes through the whole chip. due to the length of the bus, it has relatively high capacitance and larger, high-current transistors are required to drive a signal on the data bus. near the bottom of the photo are the inverter amplifiers. each sense line is attached to an inverter that boosts the signal from the stack storage. during refresh, this boosted signal is written back, strengthening the bit stored on the capacitor.10 conclusion by examining die photos, it is possible to reverse-engineer the 8008 microprocessor. one unusual feature of the 8008 is that instead of using standard binary counters internally, it saves a few gates by using shift-register counters. although these count in a pseudo-random order rather than sequentially, the 8008 still functions correctly. one counter is used for the on-chip address stack. the 8008 also uses dram internally for stack storage and register storage, requiring a second counter to refresh the dram. since every transistor was precious at the dawn of the microprocessor age, the 8008 has these interesting design decisions that produced compact circuitry. if you're interested in the 8008, my previous article has a detailed discussion of the architecture, more die photos and information on how to take them. this article explains the 8008's alu. i announce my latest blog posts on twitter, so follow me at kenshirriff. i also have an rss feed. notes and references the first announcement of the 8008 microprocessor in electronics is shown below (click for a larger version). the announcement called the chip a "parallel processor", a term that had a different meaning back then, indicating that the processor operated on all 8 bits at the same time. this was in contrast to serial processors (such as the datapoint 2200) that handled one bit of the word at a time.) ↩the 8008 chip was announced in electronics on march 13, 1972: "8-bit parallel processor offered on a single chip." in 1970, ram memory chips were extremely expensive: $99.50 for an i3101 chip with just 64 bits of storage. shift-register memory was cheaper and denser, with 512 bits of storage in an intel 1405 chip. the big disadvantage is the bits were circulated around and around inside the chip, with only one bit available at a time. sequential access wasn't a problem, but if you wanted to read memory out of order, you might need to wait half a millisecond for the right bit to circle around. i wrote about shift-register memories in detail here, with detailed die photos. ↩ the i3101 memory was called the 3101 due to intel's part numbering system at the time, described in intel technology journal, q1 2001. to summarize, the first digit indicate the product family: 1xxx is pmos, 2xxx is nmos, 3xxx is bipolar and so forth. the second digit indicates the product type: 1 is ram, 2 is a controller, 3 is rom, and so forth. the last two digits are sequence numbers typically starting with 01. thus, the first bipolar ram was the 3101. during development, the 8008 chip was called the 1201, following intel's naming scheme: the 1 indicated the chip was built from pmos technology, the 2 indicated a custom chip and the 01 was a serial number. fortunately, when it came time to market microprocessors, intel decided that marketing was more important than systematic numbering: intel's 4-bit microprocessor became the 4004 and their 8-bit microprocessor the 8008. ↩ intel introduced the i3101 chip in april 1969. the i3101 ram chip was a static memory chip, rather than the dynamic ram chips common today. it was also built from schottky ttl technology, rather than mos used in modern ram chips. other companies, such as national semiconductor, signetics and fairchild, made 64-bit memory chips compatible with the intel i3101. however, they typically used the standard 74xx numbering scheme, calling the chip the 7489. ↩ although the datapoint's stack could hold 16-bit values, the datapoint 2200 only used 13 address bits, supporting a maximum of 8k of memory. the 8008 expanded the address range to 14 bits, supporting 16k of memory, which was a huge amount at that time. however, the 8008's internal stack was only 8 values, rather than the 16 of the datapoint 2200. ↩ texas instruments heard that intel was designing a processor for datapoint and asked datapoint if they could build a processor for datapoint too. ti beat intel to the finish, creating the tmc 1795 processor before intel completed the 8008, largely because intel put the 8008 on the back burner. after datapoint rejected ti's microprocessor, ti tried to find a new customer for the chip. ti was unsuccessful, and the tmc 1795 was abandoned and mostly forgotten. i've written about the ti chip in more detail here. ↩ you may be familiar with linear-feedback shift registers (lfsrs), which can be used as pseudo-random number generators or noise generators. with n stages, a lfsr can generate 2n-1 output values. the de bruijn sequence is generated from a nonlinear-feedback shift register. nonlinear-feedback shift registers are a generalization of lfsrs; by using more complex feedback circuitry than just xor, a nonlinear feedback shift register can generate sequences of arbitrary length. in particular, it can generate a sequence of 2n values, while a lfsr is limited to 2n-1. ↩ nonlinear feedback shift registers seem pretty obscure. the only other use i've seen is the tms 0100 calculator chip, which generates an internal sequence of length 11. for information on the theory, see the synthesis of nonlinear feedback shift registers and counting with nonlinear binary feedback shift registers. the book shift register sequences goes into great detail on linear and nonlinear sequences; section vii:5 is probably most relevant, describing how to make a shift register cycle of any length. the tms 1000 microcontroller saves a few gates by using a lfsr for the program counter. instead of incrementing, the pc goes through a pseudo-random sequence. the code is stored in the rom in the same sequence; everything works out, but it seems like a strange way to implement a program counter. ↩ i was expecting the stack counter and refresh counter to have a regular layout on the chip, with a single shift register stage repeated three times. however, on the 8008 die, the transistors are arranged irregularly, scattered around where there was room. presumably this made the layout more compact. ↩ since the signal read from stack storage passes through an inverter before being written back, you might expect the bit to get flipped. the explanation is that transistor t2 in the storage cell inverts the value on c. thus, the value read from a sense line is inverted compared to the value written on the sense line. the inverter amplifier provides a second inversion, restoring the original value. ↩ each 8008 instruction takes multiple clock cycles to execute. an instruction is broken into one or more machine cycles; each machine cycle typically corresponds to one memory access for instruction or data. each machine cycle consists of up to 5 states (t1 through t5). an address is transmitted to memory during state t1 and t2, and the memory location is read or written during t3. each t state requires two clock cycles, so an 8008 instruction takes a minimum of 10 clock cycles. the intel 8008 user's manual provides detailed timings. ↩ 4 comments: links to this post email thisblogthis!share to twittershare to facebookshare to pinterest labels: 8008, reverse-engineering reverse-engineering the surprisingly advanced alu of the 8008 microprocessor a computer's arithmetic-logic unit (alu) is the heart of the processor, performing arithmetic and logic operations on data. if you've studied digital logic, you've probably learned how to combine simple binary adder circuits to build an alu. however, the 8008's alu uses clever logic circuits that can perform multiple operations efficiently. and unlike most 1970's microprocessors, the 8008 uses a complex carry-lookahead circuit to increase its performance. the 8008 was intel's first 8-bit microprocessor, introduced 45 years ago.1 while primitive by today's standards, the 8008 is historically important because it essentially started the microprocessor revolution and is the ancestor of the x86 processor family that you are probably using right now.2 i recently took some die photos of the 8008, which i described earlier. in this article, i reverse-engineer the 8008's alu circuits from these die photos and explain how the alu functions. inside the 8008 chip the image below shows the 8008's tiny silicon die, highly magnified. around the outside of the die, you can see the 18 wires connecting the die to the chip's external pins. the rest of the chip contains the chip's circuitry, built from about 3500 tiny transistors (yellow) connected by a metal wiring layer (white). die photo of the 8008 microprocessor, showing important functional blocks. many parts of the chip work together to perform an arithmetic operation. first, two values are copied from the registers (on the right side of the chip) to the alu's temporary registers (left side of the chip) via the 8-bit data bus. the alu computes the result, which is stored back into the accumulator register via the data bus. (note that the data bus splits and goes around both sides of the alu to simplify routing.) the carry lookahead circuit generates the carry bits for the sum in parallel for higher performance.3 this is all controlled by the instruction decode logic in the center of the chip that examines each machine instruction and generates signals that control the alu (and other parts of the chip). the arithmetic-logic unit the 8008's alu implements four functions: sum, and, xor and or. the sum operation adds two 8-bit numbers. the remaining three operations are standard boolean logic operations. the and operation sets an output bit if the bit is set in the first and the second number. or checks if a bit is set in the first or the second number (or both). xor (exclusive-or) checks if a bit is set in the first or the second number (but not both). the concept of carries during addition is a key part of the alu. binary addition in a processor is similar to grade-school long addition, except with binary numbers instead of decimal. starting at the right, each column of two numbers is added and there can be a carry to the next column. thus, in each column, the alu adds two bits as well as a carry bit. in most early microprocessors, addition of each column needs to wait until the column to the right has been added and the carry is available. the carry "ripples" through the bits, right to left, slowing the addition. the 8008, however, uses a fast carry-lookahead circuit3 to generate the carries for all 8 columns in parallel before the addition happens. then all the columns can all be added in parallel without waiting for the carry to "ripple" through the sum. this carry-lookahead circuit is an unusual feature to see in an early microprocessor due to its complexity. since the 8008 is an 8-bit processor, the alu operates on two eight-bit arguments. most 8-bit processors (including the 8008) use a "bit-slice" construction for the alu, with a one-bit alu slice repeated eight times. each one-bit alu slice takes two input bits and the carry-in bit, and produces the output bit. in most 8-bit processors, the bit-slice alu is arranged by stacking 8 rectangular alu slices to form a compact, regular block. however, the 8008 has its eight alu slices arranged in an irregular fashion—some blocks are even sideways—as shown in the diagram below. the motivation for this is that the carry lookahead circuit takes up a triangular space on the chip. to fit the remaining space better, the 8008's alu is arranged into its unusual triangular layout. arrangement of the eight alu slices on the 8008 microprocessor die. unlike most processors, the 8008's alu slices are arranged in a haphazard triangular arrangement. this fits better with the triangular carry-lookahead circuit above the alu. zooming in on the die photo, we can look at one of the alu slices and see how the circuitry is constructed. the chip is built from three layers (to simplify slightly). the topmost layer is the metal wiring. it is the most visible feature, and looks metallic (not surprisingly). in the detail below, you can see the horizontal and vertical metal traces. the polysilicon layer is underneath the metal layer and appears yellow/orange under the microscope. polysilicon can act as wiring, but more importantly it forms the gates of the transistors, switching them on and off. the bottom layer is the grayish silicon die itself, but it is hard to see under the other layers. die photo of the 8008 processor, zoomed in on the circuit for one bit of the alu. in the diagram above, the carry c and the complemented a and b inputs enter through the metal wires at the top. the alu output is at the bottom. the control signals are horizontal metal lines. the circuit is powered by the vcc (+5 volts) and vdd (-9 volts) metal lines. the brighter yellow polysilicon regions are transistors. each gate in the circuit requires a "load resistor" connected to vdd to pull its output low; for improved performance, these are implemented with transistors rather than resistors. removing the metal layer with acid makes the silicon and polysilicon layers more visible, as shown below.6 the chip is formed on a silicon wafer with regions of it "doped" with impurities to create regions of semiconducting silicon. you can see dark lines along the border between doped silicon and undoped silicon. a transistor is formed where a yellowish polysilicon wire crosses the doped silicon. the transistor forms a switch between the two silicon sides, controlled by the polysilicon gate. each alu slice contains 20 transistors; the diagram below points out two of them.5 with the metal layer removed from the 8008 processor die, the underlying silicon is visible. the photo shows bit 1 of the 8008's alu. simulating one slice of the alu by examining the die photos carefully, you can map out the alu slice's 20 transistors and their connections. from this, you can reverse-engineer the gates that make up the circuit. i explained in my previous article how pmos gates are structured, so i won't go into the details here. the result is the schematic below, showing one bit of the alu. each alu slice takes two inputs (a and b) and the input carry c, and outputs one result bit. there are three mode lines (m1, m2 and m3) that select one of the four alu operations.7 the schematic below is interactive. first, select an operation and the table will update with results for the eight different inputs. next, click a row in the table, and the schematic will update, showing how the alu computes that row. (note that the a and b inputs to the alu are inverted, indicated by an overbar.) operation: sum and or xor while this alu slice looks like it is made of many gates, physically it is only three gates: two large, multilevel and-or-nand gates and one nand gate. the and-or-nand logic is implemented on the chip as a single complex gate, rather than by combining simpler gates, since a single large gate provides better performance with less circuitry than multiple small gates. one feature of mos logic is it's just as easy to form an and-or-nand gate (for instance) as a plain nand gate. understanding the alu logic the 8008's alu circuit above looks like a mysterious collection of gates, but eventually i figured out the structure behind it. the starting point is a full adder that handles the sum operation. (a full adder adds three input bits (a, b and c) and outputs the (low-order) sum bit and a carry bit.) the full adder is then heavily modified to support the logic operations, yielding the alu from the previous section. the logic operations are implemented by using the mode lines to block parts of the circuit, yielding xor, and or or, rather than the more complex sum. the diagram below strips down the 8008's alu circuit to reveal the full adder "hidden" inside. the gate in red generates the carry-out from the three inverted inputs, using relatively straightforward logic. (since the 8008 uses carry-lookahead, this carry-out signal isn't passed to the next alu slice, but just used to generate the alu output.) if you examine the possible sum cases, you will see that the sum bit is almost always just the carry-out inverted, except for the 0+0+0 and 1+1+1 cases. thus, the sum bit can be generated by inverting the carry-out and handling the two exceptional cases.8 the two gates indicated below handle the exceptions by forcing the sum output to the correct value. simplified 8008 alu slice, showing the full adder circuit. comparing the full adder with the full alu circuit earlier shows how the mode lines support the logic operations. once you have a full adder, generating xor is simply a matter of setting the carry-in to 0, which is done by the m3 control line. for the or and and operations, mode lines m3 and m2 respectively disable all of the circuit except the gates labeled in green.9 thus, if you start with a full-adder and extend it to support xor, and and or, the 8008's alu circuit is a logical result. intel's earlier 4004 microprocessor had a simple alu that only supported addition and subtraction, not any logic operations.10 interestingly, the 4004's alu circuit is almost identical to the full adder circuit shown above. so it's very likely that intel designed the 8008 alu by extending the 4004 alu as described above. this would explain why the 8008's alu generates carries internally, even though the carry lookahead circuit made this redundant.11 the 8008's alu logic is very similar to the z80's alu,12 although the z80's alu is (surprisingly) 4 bits (details). the 8085 uses a different complex gate arrangement. the 6502 on the other hand, uses an entirely different approach: straightforward circuits for addition, and, or, xor and shift-right, using pass-transistor multiplexers to select the operation. instruction decoding: how the alu knows what operation to do the 8008 executes 8-bit instructions, which move data, perform i/o, branch, call subroutines, and so forth. the instruction decoding logic examines the instruction and determines what operation to perform, generating about 30 control signals.13 over a quarter of the instructions perform alu operations, and the instruction set is carefully designed so three bits of the instruction specify which of the eight operations to perform.14 by examining these bits, the instruction decoder generates the alu's mode control lines m1, m2 and m3. looking at and instructions illustrates how this works. all and instructions have the bit pattern xx100xxx (where x is either 0 or 1). for instance, the instruction to and with memory is 10100111 and the instruction to and with a constant is 00100100. when the instruction decode circuit matches this pattern, it pulls the m1 control line low, which causes the alu to perform an and operation.7 other bit patterns generate the other alu control signals.15 part of the 8008's instruction decode pla. the three indicated transistors match opcode pattern xx100xxx, indicating an and instruction. the diagram above shows part of the instruction decode circuit. the instruction bits (and their complements) are on yellow polysilicon wires running vertically through the circuit. each row matches a bit pattern, with a transistor connected to each instruction bit to be matched. (the doped silicon regions forming transistors are the black outlines. circles are connections between a transistor and the row's metal line.) for example, the three transistors marked with arrows match bit 3 low, bit 4 low, and bit 5 high, detecting the and instruction pattern. thus, the processor uses the grid of transistors in the instruction decoder to determine the meaning of each instruction. loose ends: subtraction and rotating the alu implements a sum operation, so you might wonder how subtraction is implemented. by using two's complement arithmetic, the cpu can perform subtraction by simply flipping all the bits on a value and then adding it. the alu uses two temporary registers to hold the two operands since the alu can't read the operands from the register file and write the result back simultaneously. one of the temporary registers has the feature that its value can be fed to the alu directly or inverted. the subtraction instructions generate a signal causing the temporary register to provide the inverted value to the alu, causing the alu to perform subtraction. one important operation in most processors is rotating or shifting the bits in a value, to the left or to the right. in most of the microprocessors i've examined, shifting is performed by the alu.16 the 8008, on the other hand, implements the rotate logic in the register access circuit, on the opposite side of the chip from the alu. when reading a register, the bits can be shifted one position left or right by a simple circuit before going onto the data bus. history of the 8008 the intel 8008 is important historically since it is the ancestor of the dominant intel x86 architecture that you're probably using right now.2 i wrote a detailed article for the ieee spectrum on early microprocessor history, so i'll just give the outline of the 8008's complicated history here. the 8008 copies the instruction set and architecture of the datapoint 2200, a popular minicomputer introduced in 1970 as a programmable terminal.17 as was typical for minicomputers, the datapoint 2200 contained a cpu build from individual ttl chips, filling up a circuit board. datapoint contracted with both intel and texas instruments to build a single-chip cpu that would replace this processor board, but keeping the same architecture and instruction set. the datapoint 2200 computer. the 8008 microprocessor was built to implement the datapoint 2200's architecture and instruction set. photo courtesy of austin roche. texas instruments was first to build a 2200-compatible microprocessor, creating the tmc 1795 chip. intel got their version, the 8008, working a bit later, around the end of 1971. datapoint rejected both processors, instead updating the datapoint 2200 to use the 74181 ttl alu chip. texas instruments couldn't find a new customer for the tmc 1795 and abandoned it. intel, on the other hand, came up with the idea of selling the 8008 as a well-supported general-purpose processor. the 8008 led to the 8080, the 8085, 8086, and intel's x86 line, which still retains some features of the 8008. conclusion although the 8008 was a very early microprocessor, its alu was more advanced than you might expect. in particular, it used a complex carry-lookahead circuit for higher performance. unfortunately, even with the carry-lookahead circuit, the 8008 was slower than the ttl-based datapoint 2200 processor it was supposed to replace; addition took 20µs on the 8008, compared to 16µs on the original datapoint 2200 and just 3.2µs on the upgraded datapoint 2200. this illustrates the speed advantage that ttl had over mos in the early 1970s. to us, a microprocessor may seem obviously better than a board of chips, but this wasn't always the case. if you're interested in the 8008, my previous article has a detailed discussion of the architecture, more die photos and information on how to take them, and information on semiconductor history, so take a look. i announce my latest blog posts on twitter, so follow me at kenshirriff. i also have an rss feed. notes and references the 8008 chip was publicly announced in an article in electronics on march 13, 1972, entitled "8-bit parallel processor offered on a single chip", offering the chips for $200 each. ↩ if you're not using an x86 processor right now, you're probably using an arm processor. don't feel neglected, though, since i've reverse-engineered the arm-1 too. (although there are many more arm chips out there than x86, analytics show 71% of my readers are on x86.)  ↩ using a carry look ahead circuit avoids the delay from a standard ripple-carry adder, where the carries propagate through the sum. the 8008's carry-lookahead is based on the manchester carry chain, but with a separate carry chain for each carry, yielding the triangular structure you see on the die. for performance, the carry chain is implemented with dynamic logic, depending on wire capacitance, rather than with standard boolean gates. the 74181 alu chip in comparison, uses a different carry lookahead scheme implemented with standard logic. i plan to write more about the 8008's carry lookahead later. ↩ the 8008 implements eight different arithmetic/logic functions: add, add with carry, subtract, subtract with borrow, and, xor, or, and compare.14 these are implemented in terms of the alu's four basic operations. subtraction is performed by inverting the second argument. the operations without carry/borrow clear the carry-in bit. compare is simply a subtraction that doesn't store the result; it just sets the flags with the status. thus, the four fundamental operations of the alu are used to implement eight different arithmetic/logic operations. ↩ note that the 8008 uses pmos transistors, rather than the faster nmos transistors in later microprocessors such as the 8080, 6502 and z80. if you're familiar with nmos circuits, pmos can be confusing since everything is backwards. pmos transistors turn on if the gate is low, and typically pull the output high. vdd in pmos is negative, and "ground" is positive. the "pull-up resistor" in a pmos gate pulls the output down. a pmos nand gate has transistors in parallel (compared to serial for an nmos nand gate). a pmos nor gate has transistors in serial (compared to parallel for an nmos nor gate). ↩ the metal layer of the chip is protected by silicon dioxide passivation layer. the professional way to remove this layer is with dangerous hydrofluoric acid. instead, i used armour etch glass etching cream, which is slightly safer and can be obtained at craft stores. i applied the etching cream to the die and wiped it for four minutes with a q-tip. (since the cream is designed for frosting glass, it only etches in spots. it must be moved around to obtain a uniform etch.) after this, i soaked the die in hydrochloric acid (pool acid from the hardware store) overnight to dissolve the metal. this was probably too long, since the edges of the polysilicon were eaten away in places. ↩ the following values are used for the three mode lines to select the alu function: operationm1m2m3 sum 1 1 1 and 0 1 0 or 1 0 0 xor 1 1 0  ↩ a more straightforward way of generating the sum bit is by xoring the three inputs: a⊕b⊕c. unfortunately, an xor gate is relatively difficult to implement with boolean logic, so designers will often try to avoid xor. ↩ you might wonder why the or operation is implemented with an and gate, and vice versa. since the inputs and the output of the or gate are inverted, this is equivalent to an and gate (by de morgan's laws), and similarly for the and gate. ↩ strictly speaking, the 4004 microprocessor has an au (arithmetic unit), not an alu (arithmetic/logic unit), since it doesn't do logical operations. since the 4004 was designed for a calculator, logical operations weren't required. ↩ the 8008's full adder generates the carry-out first, and generates the sum from that. in contrast, the typical full adder circuit combines two half adders to generate the sum and carry-out separately. if the typical full adder circuit had been used in the 8008, the carry-out logic could easily be omitted. ↩ to see the similarity between the z80's alu circuit and the 8008's, you need to swap and and or gates. (apply de morgan's laws since the 8008's alu inputs are inverted.) in the z80, the carry-out comes from the alu rather than a carry-lookahead circuit, so the control lines are somewhat different. but the fundamental alu circuit is otherwise the same between the 8008 and z80, which is not surprising since federico faggin worked on both chips. ↩ instruction decoding is based on a programmable logic array (pla), an arrangement of transistors that efficiently implements logic gates. these gates match bit patterns and generate the appropriate control signals for the rest of the chip. the 8008's pla has 16 input lines flow vertically through the pla. each row in the pla matches a bit pattern and generates a control signal output. in more detail, each row output line is pulled low by a load resistor/transistor to vdd. the transistors are connected between the row line and vcc (+5v). the bit lines are connected to the transistor's gate. if any bit line is low (indicating a mismatch), the pmos transistor turns on, pulling the row line high. thus, if there is no mismatch, the control line is low, and if there is a mismatch, the control line is high. in other words, each row is a nand gate with instruction bit inputs. the input lines are ordered as follows: bit 3, bit 3 complement, 4, 4', 5, 5', 0, 0', 1, 1', 2, 2', 6, 6', 7, 7'. this order may seem strange, but there's a reason for it. in the 8008, the alu operation is selected by bits 3, 4 and 5 of the instruction. by putting those bits on the left side of the pla, they are closer to the alu. some rows of the pla actually decode two instructions: bits 3, 4 and 5 are decoded on the left side, generating an alu control signal, while the remaining bits are decoded on the right side generating a different control signal. this increases the pla density and saves space on the chip. ↩ the 8008's instruction set is designed around octal. among other things, there are 8 alu operations, 8 registers and 8 conditionals. in octal, the alu instructions have the value 2ar, where a is the alu operation to perform (0 through 7) and r is the register to use (0 through 7, where 7 indicates memory). the octal structure originates with the datapoint 2200, which decoded instructions with ttl 7442 bcd chips that decoded groups of three bits. this octal structure persisted in descendants of the 8008, including the z80 and x86. unfortunately, these instruction sets are almost always presented in hexadecimal, which hides the underlying structure. ↩ the instruction decoder generates all the signals required by the alu. as described above, and matches xx100xxx, pulling the m1 control signal low. an or opcode has the bit pattern xx110xxx, which causes the instruction decode circuit to pull the m2 control line low. an xor instruction has the bit pattern xx101xxx. the m3 control line is pulled low for patterns xx10xxxx or xx1x0xxx, matching and, or or xor instructions. the subtract (with and without borrow) instructions match xx01xxxx, generating a signal that inverts the second argument. ↩ different processors use a variety of techniques for shifting. in the z80, shifting is performed as data enters the alu. the 6502 performs a left shift with "a plus a", and has a path inside the alu for right shifts; the 8085 is similar. the arm-1 has a barrel shifter next to the alu that performs arbitrary shifts. ↩ the instruction set of the datapoint 2200 is described in the reference manual. the 8008 has a couple minor changes. for instance, the 8008 has increment and decrement instructions that are not present in the 2200. ↩ 3 comments: links to this post email thisblogthis!share to twittershare to facebookshare to pinterest labels: 8008, electronics, reverse-engineering inside the 74181 alu chip: die photos and reverse engineering what's inside a ttl chip? to find out, i opened up a 74181 alu chip, took high-resolution die photos, and reverse-engineered the chip.1 inside i found several types of gates, implemented with interesting circuitry and unusual transistors. the 74181 was a popular chip in the 1970s used to perform calculations in the arithmetic-logic unit (alu) of minicomputers. it is a moderately complex chip containing about 67 gates and 170 transistors3, implemented using fast and popular ttl (transistor-transistor logic) circuitry. the 74181 die photo is below. (click the image for a high-resolution version.) the golden stripes are the metal layer that interconnects the circuitry of the chip. (it's not gold, just aluminum that looks golden from the lighting.) the white squares around the edge of the die are the pads that are connected by tiny bond wires to the external pins. under the metal layer is the silicon that makes up the chip. faint lines show the doped silicon regions that make up the transistors and resistors. while the chip may appear impossibly complex at first, with careful examination it is possible to understand how it works. die photo of the 74181 alu chip. the 74181 chip is important because of its key role in minicomputer history. before the microprocessor era, minicomputers built their processors from boards of individual chips. the arithmetic operations (addition, subtraction) and logical operations (and, or, xor) were performed by the arithmetic/logic unit (alu) in the processor. early minicomputers built alus out of a large number of simple gates. but in march 1970, texas instruments introduced the 74181 arithmetic / logic unit (alu) chip, which put a full 4-bit alu on one fast ttl chip.4 this chip provided 32 arithmetic5 and logic functions2, as well as fast carry lookahead.7 using the 74181 chip simplified the design of a minicomputer processor and made it more compact, so it was used in many minicomputers. computers using the 74181 ranged from the popular pdp-11 and nova minicomputers to the powerful vax-11/780 to the datapoint 2200 desktop computer. the 74181 is still used today in retro hacker projects.6 a brief guide to npn transistors the 74181 is built from bipolar npn transistors, a different technology from the mos transistors in modern processors. the diagram below shows how an npn transistor appears in an integrated circuit, along with a cross section. the transistor has three connections: the collector, base and emitter, with metal lines for each. the collector is connected to n-type silicon, the base to p silicon, and the emitter to n silicon (giving it the npn structure). on the chip, you can recognize the emitter from its nested squares, the base because its silicon region surrounds the emitter, and the collector because it is the largest contact. structure of an npn transistor appears in an ic. the key idea of the npn transistor is it acts as a switch between the collector and emitter, controlled by the base. normally there is no current flow between the collector and the emitter, so it's like a switch in the "off" position. but if you pass a small current from base to emitter, the transistor allows a large current from collector to emitter, like a switch in the "on" position. (this is vastly oversimplified—bipolar transistors are much more "analog"—but should be enough to understand how the 74181 works.) at the right is the symbol for an npn transistor with the collector, base and emitter labeled. inverter the fundamental component of ttl logic is the inverter, and other gates are modifications of the inverter circuit. thus, it's important to understand the basic construction of the inverter, even though it is a bit complicated. i'll explain how it works in an oversimplified way.9 the diagram below shows an inverter in the 74181 chip. the 5v and ground lines run vertically along the left, powering the inverter. the transistors are highlighted with boxes. the resistors are visible as long strips of doped silicon snaking around.11 an input pin (a0) is wired to the pad. on the right is the schematic for a ttl inverter10, with components highlighted to match the die photo. an inverter in the 74181 alu chip, along with a schematic showing the components of the inverter. the input is connected to transistor q1 (red). this transistor is used in an unusual way, acting as a "current-steering" transistor. if the input is low, r1's current is steered through q1's emitter to the input, leaving q2 off. if the input is high, r1's current flows "backwards" out q1's collector to q2's base, turning on q2. transistor q2 (orange) can be considered a "phase splitter transistor", which makes sure that exactly one of the output transistors (q3 and q4) is activated. (that is, they turn on in opposite phases.) if q2 is off, r2 provides current to turn on q3 (yellow), which pulls the output high. meanwhile, r3 turns off q4. on the other hand, if q2 turns on, it provides enough current to turn on q4 (green), which pulls the output low. i'll explain the diodes in a footnote.12 the 74181 schematic the schematic below13 shows the circuitry of the 74181. if you've taken a digital logic course, you've probably seen how to build a full adder circuit. but if you look at the schematic of the 74181, it's implemented in a very different way, to provide higher speed and more flexibility.8 the main reason for its complexity is it computes everything in parallel, rather than waiting for the carry to ripple from bit to bit, and this requires a lot more logic. the different types of gates are highlighted. there are a few inverters (red) to invert input signals. most of the logic consists of and-or-invert gates. the and stages are shown in blue, and the or-invert (nor) stages in green. (some of the or-invert stages are not explicit on the schematic and are empty boxes.) the chip uses a few xor gates (purple) to compute sums. finally, there are a couple unique gates shown in yellow. schematic of the 74181 alu. the schematic can be matched up with the labeled die image below. conveniently, the layout of the die largely matches the schematic. the and-or-invert gates make up the majority of the chip. also notice the large chip real estate used for resistors. the chip pins are labeled with blue text. (the metal layer was removed for this photo, to make the underlying circuitry more visible.) the 74181 alu die, with main gate types outlined. and-or-invert most of the 74181's logic is implemented with and-or-invert gates, which consist of and gates connected to a nor gate as shown below. after seeing the inverter, you may expect that an and-or-invert gate is very complex. but as the schematic below14 shows, the and-or-invert is not much more complex than an inverter, requiring just a few more transistors. an and gate is implemented by adding more emitters to the current-steering input transistor (red). (this may seem very strange, but transistors with multiple emitters are common in ttl circuits.) if all inputs are high, the base current will be steered to the collector. otherwise, the base current will flow out the emitter. thus, the and of the inputs is generated. the nor gate is implemented by putting phase splitter transistors in parallel (orange). if any of the bases are high, the corresponding transistor (q2a or q2b) will conduct, pulling the output low. while the circuit below has two and gates, it can easily be extended to as many gates and inputs as desired. the and-or-invert circuit from the 7451 chip. the multiple-emitter transistors that implement and are highlighted in red. the transistors that implement or are highlighted in orange. the diagram below shows how these multiple-emitter transistors are implemented on the chip. three of these transistors are shown, each with four or five emitters (the dark squares), creating 4-input or 5-input and gates. each transistor's base is at the top and each collector is at the bottom. the signal lines run horizontally, with emitters connected as needed. with this structure, multiple and gates can arranged efficiently on the chip (similar to a programmable logic array or pla). note that the base resistors take up a significant amount of space. three and gates in the 74181 alu chip. each one is a single transistor with multiple emitters. the diagram below shows how the or-invert part of the circuit appears on the chip. note that q2a and q2b (orange) share a collector, so the two transistors don't take up much space on the die. their inputs come from and circuits such as the ones above. 3-input and 4-input or gates are implemented similarly, by adding more transistors. the or-invert stage of the and-or-invert gate in the 74181, compared with the 7451 and-or-invert gate. exclusive-or the chip uses a clever, compact circuit to compute xor with two transistors wired in an unusual way: the emitters and bases are tied together and there is no connection to ground. the way it works is if the first input is high and the second is low, the first transistor turns on due to the base-emitter current. this pulls the output low through the transistor, with the second input acting as ground. likewise, if the first input is low and the second is high, the second transistor turns on and pulls the output low. if both inputs are the same, there is no base-emitter current, both transistors remain off, and the output is pulled high by the resistor. the output from the transistor pair goes to the standard inverter stage, so the resulting signal is the xor of the two inputs. 15 as with or-invert, the two transistors share a collector, making the layout more compact. the circuit used in the 74181 to compute xor. layout inspired by userbinator. a few things to note about the photo. the two transistors share a collector, which is equivalent to wiring their collectors together. the pull-up resistor doesn't appear in the photo; it is off to the right. the inputs to the xor are from and-or-invert gates; their output transistors are at the top of the photo. not-and the chip uses four and gates that have one inverted input.17 on the die, it appears at first that the gates are implemented with the standard and transistors, but an interesting trick is used to invert one of the inputs. transistor q1 is wired in the normal current-steering way, with r1 providing a base current. but transistor q2 has its resistor connected to the collector, not the base.16 normally r2 will pull the output high. but if input x is high and input y is low, r1's current will go through q1's collector and q2's emitter, turning on q2 and pulling the output low. thus, the result after the inverter stage will be x and not y. the 74181 uses an interesting circuit to generate not-and. it uses the multi-emitter transistors but in a subtly different way from the and gates. getting the die photos to create die photos, the integrated circuit package must be opened to expose the silicon die inside. most chips have an epoxy package, which can be dissolved in boiling sulfuric acid. since i don't like boiling acid, i obtained the 74181 chip in a ceramic package, which is much easier to open. the 74181 alu chip in a ceramic package. i tapped the chip along the seam with a chisel, splitting the two layers apart. below, you can see how the metal pins are mounted between the layers, and are connected to the silicon die with tiny bond wires. by tapping the 74181 chip with a chisel, the ceramic package can be popped open. to photograph the die, i used a metallurgical microscope, a special type of microscope that shines light down through the lens to illuminate the chip from above. i took 22 photographs and then used the hugin stitching software to combine them into a high-resolution image (details). then, i removed the metal layer from the chip with hydrochloric acid and took more images, resulting in the image below. removing the metal makes it easier to see the structure of the silicon layer and determine how the chip works. (click for high-resolution version.) removing the metal layer of the 74181 chip with hcl reveals the silicon layer underneath. conclusion the 74181 alu chip is a complex, high-performance ttl chip that was a key component in the processor of many minicomputers. i took detailed die photos of the 74181 alu that reveal how the chip works internally. it uses several different logic gates, primarily and-or-invert gates that have an efficient layout on the chip. these gates are implemented by extending an inverter circuit in different ways, but are more complex than their mos equivalents. i plan to explain how the 74181 implements its 32 functions and fast carry in a future article, so keep watching. i announce my latest blog posts on twitter, so follow me at kenshirriff. i also have an rss feed. notes and references to understand what's inside a ttl chip, it might be more sensible to start with a simple chip such as a nand gate. but why take the easy way when there's a complex chip to explore? ↩ many of the 74181's 32 functions are strange, but there is actually a system behind it. note that there are exactly 16 possible functions on two (one-bit) binary inputs a and b. (there are 4 lines in the truth table, and two choices for each output, so 2^4 possible functions.) the 74181's 16 logic functions are simply these 16 functions (extended to 4 bits). the 74181's 16 arithmetic functions are a plus (one of the 16 possible functions of a and b) plus carry-in. ↩ various sources say the 74181 has 61 or 75 gates. the schematic shows 67 gates. if you omit the five 1-input and gates, you get 62 gates, i. on the die, i counted 169 transistors, but it's quite possible i missed some. ↩ the history of the 74181 chip is described in detail on this site. the 74181 is apparently the first alu chip created. in 1968, fairchild introduced the 3800, an 8-bit accumulator chip, but it didn't have logical functions so technically it's just an au (arithmetic unit) not an alu like the 74181. before the 74181 was the 7483 4-bit adder chip (1968); internally, the 7483 is similar to the lower half of the 74181. the 7483 was used in minicomputers such as the pdp 8/e. ↩ alu chips of this era didn't perform multiplication or division, let alone floating point operations. multiplication and division operations were common in computers of that era, but were typically performed with multiple cycles of addition or subtraction. the one operation that seems missing from the 74181 is "shift right"; it can do a shift left with "a plus a". ↩ retro projects using the 74181 include the apollo181 cpu, fourbit cpu, 4 bit ttl cpu, magic-1 (using the 74f381), trex, mark 1 forth and big mess o' wires. ↩ when multiple 74181 chips are connected together for larger words, you can simply feed the carry-out of one chip into the carry-in of the next. for higher performance, the 74182 look-ahead carry generator could be used to compute the carries across multiple chips in parallel. some minicomputers (such as the xerox alto) didn't use the 74182, while others (such as the interdata 7/16) did. ↩ i'll give a brief overview of the chip's implementation here. the chip is build around the idea of carry lookahead. in particular, the upper and-or-invert gates create the carry p (propagate) and g (generate) signals for each bit of a plus f(a,b). the lower and-or-invert gates use these signals to compute the carry for each bit of the sum. finally, the xor gates add the p, g and carry to compute each final sum. the point of this implementation is to compute the four bits in parallel and avoid a slow ripple carry. in a later post i'll explain this circuitry in full detail. ↩ i've simplified the discussion of the ttl logic circuit, since most people probably don't care about saturation, β, biasing, and so forth. if you want the full analysis, see logic gates: the not gate or transistor-transistor logic. this presentation shows schematics for the different gates and ttl logic families. ↩ the inverter schematic is from the datasheet of the common 7404 inverter chip. interestingly, the basic circuit used in an inverter chip is almost identical to the circuit used inside the 74181. this turns out to be true for most of the 74181 circuits—they are similar to individual ttl parts. the 74181's transistors are a bit smaller because not as much current is required inside the chip, but there is much less scaling than you might expect. ↩ in the 74181's inverter, r4 is not used. r1 takes its place. this is probably because an inverter in the chip doesn't need to provide as much current as a 7404 inverter chip. ↩ the tricky part of the inverter circuit is that if q2 turns on, there's enough voltage to turn on q4 but not q3, thanks to diode d2. the purpose of diode d2 isn't to conduct current in one direction, like you'd expect from a diode. instead, its purpose is to raise q3's emitter voltage by one diode drop (about 0.7v). as a consequence, q3 requires 0.7v more at the base to turn on. thus, when q2 is active, there is enough voltage to turn q4 on, but not q3. and diode d1 simply protects the chip by shunting any negative input voltage to ground. ↩ the schematic is based on a diagram by poil on wikimedia, cc by-sa 3.0, with labeling changes and gates highlighted. ↩ the and-or-invert schematic is slightly modified from the 7451 and-or-invert chip to match the 74181's circuit. the 74181's and-or-invert circuits in the lower half of the chip omit the pull-up output transistor found in the 7451 since the 74181 doesn't require as much output current internally. (the output diode remains to drop the phase splitter transistor's collector voltage by one diode drop, or else the low output voltage will be too high.) ↩ the circuit used in the 74181 for exclusive-or is similar to the 7486 ttl xor chip. ↩ on the die, q2 appears to have two collectors. but these are just two contacts to the same collector, to simplify routing of the wiring. this is unlike the multiple-emitter transistors, which genuinely have multiple emitters. ↩ some datasheets (example) show an xor gate instead of not-and. you might wonder how this could possibly work since xor and not-and are different. the answer is that one of the four input combinations never happens in the 74181, and the gates are equivalent across the other three inputs. the physical implementation is not-and rather than xor. ↩ 11 comments: links to this post email thisblogthis!share to twittershare to facebookshare to pinterest labels: electronics, reverse-engineering older posts home popular posts inside the vintage 74181 alu chip: how it works and why it's so strange analyzing the vintage 8008 processor from die photos: its unusual counters a multi-protocol infrared remote library for the arduino a dozen usb chargers in the lab: apple is very good, but not quite the best apple iphone charger teardown: quality in a tiny expensive package macbook charger teardown: the surprising complexity inside apple's power adapter teardown and exploration of apple's magsafe connector ipad charger teardown: inside apple's charger and a risky phony labels 6502 8008 8085 alto apple arc arduino arm beaglebone bitcoin c# calculator css electronics f# fractals genome haskell html5 ibm1401 ipv6 ir java javascript math oscilloscope photo power supply random reverse-engineering sheevaplug snark spanish teardown theory unicode z-80 power supply posts iphone charger teardown a dozen usb chargers magsafe hacking inside a fake iphone charger power supply history blog archive ▼  2017 (4) ▼  march (2) inside the vintage 74181 alu chip: how it works an... analyzing the vintage 8008 processor from die phot... ►  february (1) ►  january (1) ►  2016 (34) ►  december (2) ►  october (5) ►  september (8) ►  august (2) ►  july (3) ►  june (4) ►  may (1) ►  april (1) ►  march (1) ►  february (4) ►  january (3) ►  2015 (12) ►  december (2) ►  november (1) ►  october (3) ►  august (1) ►  may (2) ►  march (2) ►  february (1) ►  2014 (13) ►  december (1) ►  october (1) ►  september (3) ►  may (2) ►  march (1) ►  february (5) ►  2013 (24) ►  november (2) ►  september (4) ►  august (4) ►  july (4) ►  june (2) ►  april (1) ►  march (2) ►  february (2) ►  january (3) ►  2012 (10) ►  december (1) ►  november (5) ►  october (1) ►  may (1) ►  march (1) ►  february (1) ►  2011 (11) ►  december (2) ►  july (2) ►  may (2) ►  april (1) ►  march (1) ►  february (3) ►  2010 (22) ►  december (2) ►  november (4) ►  october (3) ►  august (1) ►  june (1) ►  may (2) ►  april (3) ►  march (4) ►  january (2) ►  2009 (22) ►  december (2) ►  november (5) ►  september (1) ►  august (3) ►  july (1) ►  june (3) ►  april (1) ►  march (3) ►  february (2) ►  january (1) ►  2008 (27) ►  july (3) ►  june (1) ►  may (3) ►  april (4) ►  march (10) ►  february (6) amazon.com widgets--> quick links arduino ir library 6502 reverse-engineering simple theme. powered by blogger.


Here you find all texts from your page as Google (googlebot) and others search engines seen it.

Words density analysis:

Numbers of all words: 13721

One word

Two words phrases

Three words phrases

the - 11.41% (1565)
and - 3.05% (419)
for - 1.54% (211)
bit - 1.26% (173)
chip - 1.22% (168)
are - 1.21% (166)
put - 1.17% (160)
alu - 1.14% (157)
era - 1.09% (150)
gate - 0.87% (119)
8008 - 0.86% (118)
out - 0.86% (118)
carry - 0.84% (115)
with - 0.81% (111)
transistor - 0.77% (105)
low - 0.74% (102)
all - 0.74% (101)
circuit - 0.73% (100)
use - 0.7% (96)
74181 - 0.7% (96)
how - 0.69% (95)
logic - 0.68% (93)
add - 0.66% (91)
that - 0.64% (88)
its - 0.64% (88)
this - 0.63% (87)
process - 0.63% (87)
processor - 0.61% (84)
►  - 0.59% (81)
you - 0.56% (77)
rom - 0.55% (75)
from - 0.53% (73)
line - 0.49% (67)
invert - 0.47% (65)
one - 0.47% (65)
data - 0.47% (65)
here - 0.47% (64)
gates - 0.45% (62)
die - 0.45% (62)
function - 0.44% (61)
transistors - 0.44% (61)
operation - 0.44% (61)
each - 0.44% (61)
red - 0.43% (59)
act - 0.41% (56)
 ↩ - 0.41% (56)
can - 0.41% (56)
generate - 0.4% (55)
but - 0.4% (55)
input - 0.39% (54)
form - 0.38% (52)
not - 0.38% (52)
stack - 0.36% (50)
was - 0.36% (50)
functions - 0.36% (50)
ram - 0.36% (49)
output - 0.35% (48)
instruction - 0.35% (48)
silicon - 0.34% (47)
compute - 0.34% (47)
there - 0.34% (46)
show - 0.34% (46)
implement - 0.33% (45)
look - 0.33% (45)
mos - 0.32% (44)
high - 0.32% (44)
photo - 0.32% (44)
used - 0.31% (43)
point - 0.31% (42)
shift - 0.31% (42)
two - 0.29% (40)
more - 0.29% (40)
intel - 0.29% (40)
signal - 0.28% (39)
operations - 0.27% (37)
register - 0.27% (37)
bits - 0.27% (37)
count - 0.26% (36)
side - 0.26% (36)
pla - 0.26% (36)
arithmetic - 0.26% (36)
value - 0.26% (36)
led - 0.26% (35)
which - 0.26% (35)
datapoint - 0.26% (35)
microprocessor - 0.26% (35)
connect - 0.25% (34)
below - 0.25% (34)
chip. - 0.25% (34)
8008's - 0.24% (33)
or, - 0.24% (33)
perform - 0.24% (33)
ahead - 0.23% (32)
on. - 0.23% (32)
has - 0.23% (32)
metal - 0.23% (31)
xor - 0.22% (30)
layer - 0.22% (30)
on, - 0.22% (30)
addition - 0.22% (30)
range - 0.22% (30)
see - 0.22% (30)
sum - 0.22% (30)
lookahead - 0.21% (29)
first - 0.21% (29)
using - 0.21% (29)
arc - 0.2% (28)
way - 0.2% (28)
lines - 0.2% (28)
uses - 0.2% (28)
since - 0.2% (27)
other - 0.2% (27)
2200 - 0.2% (27)
right - 0.2% (27)
than - 0.2% (27)
inputs - 0.19% (26)
schematic - 0.19% (26)
(1) - 0.19% (26)
emitter - 0.19% (26)
control - 0.19% (26)
call - 0.19% (26)
inverter - 0.19% (26)
adder - 0.18% (25)
set - 0.18% (25)
it. - 0.18% (25)
base - 0.18% (25)
current - 0.18% (25)
counter - 0.18% (25)
full - 0.18% (25)
try - 0.17% (24)
row - 0.17% (24)
ttl - 0.17% (24)
turn - 0.17% (24)
sequence - 0.17% (24)
chips - 0.17% (23)
back - 0.17% (23)
shows - 0.16% (22)
under - 0.16% (22)
most - 0.16% (22)
plus - 0.16% (22)
pull - 0.16% (22)
minicomputer - 0.16% (22)
complex - 0.16% (22)
these - 0.16% (22)
three - 0.15% (21)
any - 0.15% (21)
or-invert - 0.15% (21)
implemented - 0.15% (21)
signals - 0.15% (21)
pin - 0.15% (21)
part - 0.15% (21)
circuitry - 0.15% (21)
work - 0.15% (21)
will - 0.15% (21)
computers - 0.15% (20)
through - 0.15% (20)
processors - 0.15% (20)
parallel - 0.15% (20)
connected - 0.14% (19)
different - 0.14% (19)
memory - 0.14% (19)
subtract - 0.14% (19)
(2) - 0.14% (19)
detail - 0.14% (19)
result - 0.14% (19)
us, - 0.14% (19)
match - 0.14% (19)
collector - 0.14% (19)
or. - 0.13% (18)
code - 0.13% (18)
carry-in - 0.13% (18)
inside - 0.13% (18)
reverse - 0.13% (18)
above - 0.13% (18)
select - 0.12% (17)
bus - 0.12% (17)
around - 0.12% (17)
left - 0.12% (17)
storage - 0.12% (17)
have - 0.12% (17)
thus, - 0.12% (17)
rest - 0.12% (17)
get - 0.12% (17)
store - 0.12% (17)
they - 0.12% (17)
internal - 0.12% (17)
second - 0.12% (17)
like - 0.12% (17)
read - 0.12% (16)
low. - 0.12% (16)
chip, - 0.12% (16)
multiple - 0.12% (16)
slice - 0.12% (16)
term - 0.12% (16)
photos - 0.12% (16)
circuits - 0.12% (16)
generated - 0.12% (16)
just - 0.12% (16)
four - 0.12% (16)
and-or-invert - 0.12% (16)
march - 0.12% (16)
large - 0.12% (16)
long - 0.12% (16)
subtraction - 0.12% (16)
down - 0.11% (15)
provide - 0.11% (15)
propagate - 0.11% (15)
plain - 0.11% (15)
may - 0.11% (15)
minicomputers - 0.11% (15)
very - 0.11% (15)
share - 0.11% (15)
take - 0.11% (15)
boolean - 0.11% (15)
top - 0.11% (15)
decode - 0.1% (14)
74181's - 0.1% (14)
polysilicon - 0.1% (14)
rather - 0.1% (14)
values - 0.1% (14)
and, - 0.1% (14)
reverse-engineer - 0.1% (14)
diagram - 0.1% (14)
some - 0.1% (14)
between - 0.1% (14)
thin - 0.1% (14)
mode - 0.1% (14)
article - 0.1% (14)
8008, - 0.1% (14)
note - 0.1% (14)
feed - 0.1% (14)
it's - 0.1% (14)
wire - 0.1% (14)
number - 0.1% (14)
similar - 0.1% (14)
off - 0.1% (14)
works - 0.1% (14)
order - 0.09% (13)
indicate - 0.09% (13)
simple - 0.09% (13)
registers - 0.09% (13)
nor - 0.09% (13)
pmos - 0.09% (13)
built - 0.09% (13)
outputs - 0.09% (13)
(3) - 0.09% (13)
wiring - 0.09% (13)
design - 0.09% (13)
post - 0.09% (13)
8-bit - 0.09% (13)
resistor - 0.09% (13)
while - 0.09% (13)
low, - 0.09% (13)
alu. - 0.09% (13)
appear - 0.09% (13)
expect - 0.09% (12)
when - 0.09% (12)
instead - 0.09% (12)
such - 0.09% (12)
too - 0.09% (12)
time - 0.09% (12)
near - 0.09% (12)
explain - 0.09% (12)
their - 0.09% (12)
structure - 0.09% (12)
4-bit - 0.09% (12)
inverted - 0.09% (12)
end - 0.09% (12)
both - 0.09% (12)
(a, - 0.09% (12)
blog - 0.09% (12)
about - 0.09% (12)
unit - 0.09% (12)
where - 0.09% (12)
many - 0.09% (12)
die, - 0.09% (12)
address - 0.09% (12)
doped - 0.09% (12)
light - 0.09% (12)
make - 0.09% (12)
gates. - 0.09% (12)
were - 0.09% (12)
possible - 0.09% (12)
case - 0.09% (12)
stored - 0.08% (11)
then - 0.08% (11)
pattern - 0.08% (11)
only - 0.08% (11)
power - 0.08% (11)
instructions - 0.08% (11)
important - 0.08% (11)
implements - 0.08% (11)
column - 0.08% (11)
there's - 0.08% (11)
strange - 0.08% (11)
f(a, - 0.08% (11)
write - 0.08% (11)
why - 0.08% (11)
processor, - 0.08% (11)
thing - 0.08% (11)
bit. - 0.08% (11)
standard - 0.08% (11)
cpu - 0.08% (11)
board - 0.08% (11)
gates, - 0.08% (11)
linear - 0.08% (11)
story - 0.08% (11)
logical - 0.08% (11)
few - 0.08% (11)
old - 0.08% (11)
voltage - 0.08% (11)
unusual - 0.08% (11)
build - 0.08% (11)
before - 0.08% (11)
what - 0.08% (11)
next - 0.08% (11)
carries - 0.08% (11)
charge - 0.07% (10)
architecture - 0.07% (10)
feedback - 0.07% (10)
refresh - 0.07% (10)
could - 0.07% (10)
sense - 0.07% (10)
support - 0.07% (10)
carry-lookahead - 0.07% (10)
eight - 0.07% (10)
addition, - 0.07% (10)
carry-out - 0.07% (10)
turns - 0.07% (10)
operations. - 0.07% (10)
probably - 0.07% (10)
performance - 0.07% (10)
100 - 0.07% (10)
into - 0.07% (10)
same - 0.07% (10)
binary - 0.07% (10)
you're - 0.07% (10)
fast - 0.07% (10)
main - 0.07% (10)
pop - 0.07% (10)
create - 0.07% (10)
generates - 0.07% (10)
position - 0.07% (10)
though - 0.07% (10)
them - 0.07% (10)
typical - 0.07% (10)
yellow - 0.07% (10)
1970 - 0.07% (10)
single - 0.07% (10)
f(a,b) - 0.07% (10)
february - 0.07% (9)
formed - 0.07% (9)
random - 0.07% (9)
nand - 0.07% (9)
might - 0.07% (9)
feature - 0.07% (9)
(4) - 0.07% (9)
layout - 0.07% (9)
does - 0.07% (9)
transistors, - 0.07% (9)
cell - 0.07% (9)
intel's - 0.07% (9)
pins - 0.07% (9)
operations, - 0.07% (9)
together - 0.07% (9)
also - 0.07% (9)
however, - 0.07% (9)
because - 0.07% (9)
announce - 0.07% (9)
compare - 0.07% (9)
charger - 0.07% (9)
except - 0.07% (9)
gate. - 0.07% (9)
engineering - 0.07% (9)
wires - 0.07% (9)
much - 0.07% (9)
001 - 0.07% (9)
nonlinear - 0.07% (9)
table - 0.07% (9)
age, - 0.07% (9)
history - 0.07% (9)
shown - 0.07% (9)
is, - 0.07% (9)
datasheet - 0.07% (9)
follow - 0.07% (9)
require - 0.07% (9)
3101 - 0.07% (9)
described - 0.06% (8)
stage - 0.06% (8)
appears - 0.06% (8)
x86 - 0.06% (8)
image - 0.06% (8)
visible - 0.06% (8)
cycle - 0.06% (8)
combine - 0.06% (8)
z80 - 0.06% (8)
adding - 0.06% (8)
straightforward - 0.06% (8)
ground - 0.06% (8)
interesting - 0.06% (8)
below. - 0.06% (8)
ripple - 0.06% (8)
- 0.06% (8)
new - 0.06% (8)
seem - 0.06% (8)
ranged - 0.06% (8)
reverse-engineering - 0.06% (8)
diode - 0.06% (8)
000 - 0.06% (8)
conduct - 0.06% (8)
acid - 0.06% (8)
move - 0.06% (8)
region - 0.06% (8)
logic, - 0.06% (8)
understand - 0.06% (8)
microprocessors - 0.06% (8)
word - 0.06% (8)
simply - 0.06% (8)
electronics - 0.06% (8)
dram - 0.06% (8)
tiny - 0.05% (7)
showing - 0.05% (7)
capacitor - 0.05% (7)
microprocessor, - 0.05% (7)
resistors - 0.05% (7)
stack. - 0.05% (7)
forth - 0.05% (7)
yield - 0.05% (7)
i3101 - 0.05% (7)
shift-register - 0.05% (7)
counters - 0.05% (7)
program - 0.05% (7)
provides - 0.05% (7)
generating - 0.05% (7)
need - 0.05% (7)
words - 0.05% (7)
start - 0.05% (7)
compared - 0.05% (7)
posts - 0.05% (7)
based - 0.05% (7)
compact - 0.05% (7)
every - 0.05% (7)
april - 0.05% (7)
bus. - 0.05% (7)
ken - 0.05% (7)
bits, - 0.05% (7)
behind - 0.05% (7)
performed - 0.05% (7)
sum. - 0.05% (7)
chip's - 0.05% (7)
above. - 0.05% (7)
final - 0.05% (7)
early - 0.05% (7)
made - 0.05% (7)
popular - 0.05% (7)
over - 0.05% (7)
takes - 0.05% (7)
npn - 0.05% (7)
emitters - 0.05% (7)
must - 0.05% (7)
regions - 0.05% (7)
did - 0.05% (7)
along - 0.05% (7)
added - 0.05% (7)
collector, - 0.05% (7)
system - 0.05% (7)
pass - 0.05% (7)
arm - 0.05% (7)
in. - 0.05% (7)
emitter, - 0.05% (7)
hand, - 0.05% (7)
functions. - 0.05% (7)
called - 0.05% (7)
circuit. - 0.05% (7)
introduced - 0.05% (7)
took - 0.05% (7)
slow - 0.05% (7)
(the - 0.05% (7)
december - 0.05% (7)
processors, - 0.05% (7)
i'll - 0.05% (7)
even - 0.05% (7)
key - 0.05% (7)
cross - 0.04% (6)
pulls - 0.04% (6)
doesn't - 0.04% (6)
reason - 0.04% (6)
carry-in. - 0.04% (6)
this, - 0.04% (6)
designed - 0.04% (6)
save - 0.04% (6)
internally - 0.04% (6)
today - 0.04% (6)
labeled - 0.04% (6)
larger - 0.04% (6)
detailed - 0.04% (6)
creating - 0.04% (6)
bit, - 0.04% (6)
functions, - 0.04% (6)
highlighted - 0.04% (6)
instance, - 0.04% (6)
74181, - 0.04% (6)
extend - 0.04% (6)
vintage - 0.04% (6)
i've - 0.04% (6)
higher - 0.04% (6)
(or - 0.04% (6)
ic. - 0.04% (6)
surprising - 0.04% (6)
june - 0.04% (6)
matches - 0.04% (6)
bottom - 0.04% (6)
produce - 0.04% (6)
inputs. - 0.04% (6)
earlier - 0.04% (6)
indicated - 0.04% (6)
high, - 0.04% (6)
arranged - 0.04% (6)
typically - 0.04% (6)
package - 0.04% (6)
always - 0.04% (6)
written - 0.04% (6)
(and - 0.04% (6)
blue - 0.04% (6)
carry. - 0.04% (6)
high. - 0.04% (6)
remove - 0.04% (6)
arithmetic/logic - 0.04% (6)
bruijn - 0.04% (6)
forms - 0.04% (6)
onto - 0.04% (6)
apple - 0.04% (6)
switch - 0.04% (6)
cpu, - 0.04% (6)
book - 0.04% (6)
teardown - 0.04% (6)
above, - 0.04% (6)
click - 0.04% (6)
examine - 0.04% (6)
keep - 0.04% (6)
solution - 0.04% (6)
less - 0.04% (6)
type - 0.04% (6)
after - 0.04% (6)
moved - 0.04% (6)
simplified - 0.04% (6)
shifted - 0.04% (6)
well - 0.04% (6)
(alu) - 0.04% (6)
circuit, - 0.04% (6)
digit - 0.04% (6)
4004 - 0.04% (6)
finally - 0.04% (6)
labels - 0.04% (6)
instruments - 0.04% (6)
texas - 0.04% (6)
modern - 0.04% (6)
reference - 0.04% (5)
connection - 0.04% (5)
pulled - 0.04% (5)
combination - 0.04% (5)
pseudo-random - 0.04% (5)
connecting - 0.04% (5)
implementation - 0.04% (5)
exactly - 0.04% (5)
red. - 0.04% (5)
november - 0.04% (5)
chip: - 0.04% (5)
july - 0.04% (5)
august - 0.04% (5)
combined - 0.04% (5)
counter. - 0.04% (5)
october - 0.04% (5)
project - 0.04% (5)
january - 0.04% (5)
being - 0.04% (5)
arbitrary - 0.04% (5)
don't - 0.04% (5)
chips. - 0.04% (5)
separate - 0.04% (5)
shifting - 0.04% (5)
rows - 0.04% (5)
performance. - 0.04% (5)
not-and - 0.04% (5)
remain - 0.04% (5)
time. - 0.04% (5)
consist - 0.04% (5)
2200. - 0.04% (5)
things - 0.04% (5)
particular - 0.04% (5)
inverter, - 0.04% (5)
component - 0.04% (5)
processor. - 0.04% (5)
terminal - 0.04% (5)
you've - 0.04% (5)
one-bit - 0.04% (5)
subroutine - 0.04% (5)
computes - 0.04% (5)
works. - 0.04% (5)
previous - 0.04% (5)
let - 0.04% (5)
enter - 0.04% (5)
operation. - 0.04% (5)
lines. - 0.04% (5)
finally, - 0.04% (5)
almost - 0.04% (5)
access - 0.04% (5)
via - 0.04% (5)
6502 - 0.04% (5)
parts - 0.04% (5)
change - 0.04% (5)
me, - 0.04% (5)
slices - 0.04% (5)
half - 0.04% (5)
complicated - 0.04% (5)
signals. - 0.04% (5)
test - 0.04% (5)
although - 0.04% (5)
complement - 0.04% (5)
vertical - 0.04% (5)
first, - 0.04% (5)
lfsr - 0.04% (5)
mark - 0.04% (5)
during - 0.04% (5)
example - 0.04% (5)
information - 0.04% (5)
triangular - 0.04% (5)
determine - 0.04% (5)
cycles - 0.04% (5)
makes - 0.04% (5)
once - 0.04% (5)
74181. - 0.04% (5)
serial - 0.04% (5)
avoid - 0.04% (5)
etch - 0.04% (5)
removed - 0.04% (5)
space - 0.04% (5)
wait - 0.04% (5)
state - 0.04% (5)
block - 0.04% (5)
without - 0.04% (5)
layers - 0.04% (5)
had - 0.04% (5)
efficient - 0.04% (5)
nmos - 0.04% (5)
links - 0.04% (5)
dynamic - 0.04% (5)
external - 0.04% (5)
care - 0.03% (4)
here. - 0.03% (4)
01. - 0.03% (4)
fortunately, - 0.03% (4)
generator - 0.03% (4)
common - 0.03% (4)
tell - 0.03% (4)
transistors. - 0.03% (4)
tmc - 0.03% (4)
everything - 0.03% (4)
temporary - 0.03% (4)
machine - 0.03% (4)
clock - 0.03% (4)
september - 0.03% (4)
(5) - 0.03% (4)
arrangement - 0.03% (4)
better - 0.03% (4)
looks - 0.03% (4)
regular - 0.03% (4)
1795 - 0.03% (4)
vdd - 0.03% (4)
forth. - 0.03% (4)
goes - 0.03% (4)
sequences - 0.03% (4)
xor, - 0.03% (4)
arduino - 0.03% (4)
purpose - 0.03% (4)
details - 0.03% (4)
numbers - 0.03% (4)
7451 - 0.03% (4)
bipolar - 0.03% (4)
high-resolution - 0.03% (4)
underlying - 0.03% (4)
visible. - 0.03% (4)
controlled - 0.03% (4)
sides - 0.03% (4)
transistor's - 0.03% (4)
forming - 0.03% (4)
silicon. - 0.03% (4)
later - 0.03% (4)
conductor - 0.03% (4)
1970s - 0.03% (4)
present - 0.03% (4)
acts - 0.03% (4)
octal - 0.03% (4)
decoded - 0.03% (4)
equivalent - 0.03% (4)
pulling - 0.03% (4)
turning - 0.03% (4)
(arithmetic - 0.03% (4)
appropriate - 0.03% (4)
plan - 0.03% (4)
desired - 0.03% (4)
logic. - 0.03% (4)
decoder - 0.03% (4)
technology - 0.03% (4)
8085 - 0.03% (4)
counting - 0.03% (4)
lower - 0.03% (4)
omit - 0.03% (4)
meaning - 0.03% (4)
flow - 0.03% (4)
phase - 0.03% (4)
stages - 0.03% (4)
storage. - 0.03% (4)
required - 0.03% (4)
length - 0.03% (4)
due - 0.03% (4)
photo. - 0.03% (4)
give - 0.03% (4)
programmable - 0.03% (4)
enough - 0.03% (4)
(orange) - 0.03% (4)
gate, - 0.03% (4)
requires - 0.03% (4)
created - 0.03% (4)
wiring. - 0.03% (4)
putting - 0.03% (4)
comments: - 0.03% (4)
email - 0.03% (4)
retro - 0.03% (4)
thisblogthis!share - 0.03% (4)
twittershare - 0.03% (4)
pinterest - 0.03% (4)
labels: - 0.03% (4)
still - 0.03% (4)
13, - 0.03% (4)
case. - 0.03% (4)
(generate) - 0.03% (4)
values, - 0.03% (4)
(click - 0.03% (4)
ram. - 0.03% (4)
minicomputers. - 0.03% (4)
normal - 0.03% (4)
(propagate) - 0.03% (4)
interact - 0.03% (4)
date - 0.03% (4)
section - 0.03% (4)
individual - 0.03% (4)
terms - 0.03% (4)
circuitry. - 0.03% (4)
pins. - 0.03% (4)
indicates - 0.03% (4)
come - 0.03% (4)
out. - 0.03% (4)
conclusion - 0.03% (4)
latest - 0.03% (4)
twitter, - 0.03% (4)
kenshirriff. - 0.03% (4)
notes - 0.03% (4)
references - 0.03% (4)
projects - 0.03% (4)
photos, - 0.03% (4)
truth - 0.03% (4)
adds - 0.03% (4)
chain - 0.03% (4)
find - 0.03% (4)
providing - 0.03% (4)
chips, - 0.03% (4)
simplify - 0.03% (4)
relative - 0.03% (4)
fed - 0.03% (4)
examining - 0.03% (4)
physical - 0.03% (4)
inverted, - 0.03% (4)
include - 0.03% (4)
similarly - 0.03% (4)
expected - 0.03% (4)
slightly - 0.03% (4)
either - 0.03% (4)
facebookshare - 0.03% (4)
consider - 0.03% (4)
provided - 0.03% (4)
cases - 0.03% (4)
subtraction, - 0.03% (4)
small - 0.03% (4)
powered - 0.03% (4)
unit) - 0.03% (4)
would - 0.03% (4)
surprisingly - 0.03% (4)
handle - 0.03% (4)
didn't - 0.03% (4)
microprocessors, - 0.03% (4)
white - 0.03% (4)
circuits. - 0.03% (4)
track - 0.03% (4)
hold - 0.03% (4)
resulting - 0.03% (4)
origin - 0.03% (4)
article, - 0.03% (4)
indicating - 0.02% (3)
74182 - 0.02% (3)
r1's - 0.02% (3)
(such - 0.02% (3)
way, - 0.02% (3)
starting - 0.02% (3)
bizarre - 0.02% (3)
removing - 0.02% (3)
across - 0.02% (3)
performs - 0.02% (3)
additional - 0.02% (3)
components - 0.02% (3)
1xxx - 0.02% (3)
product - 0.02% (3)
1+1+c - 0.02% (3)
you'd - 0.02% (3)
wired - 0.02% (3)
several - 0.02% (3)
numbering - 0.02% (3)
parallel, - 0.02% (3)
splitter - 0.02% (3)
q1's - 0.02% (3)
saves - 0.02% (3)
(on - 0.02% (3)
arrows - 0.02% (3)
forcing - 0.02% (3)
update - 0.02% (3)
relatively - 0.02% (3)
golden - 0.02% (3)
(red) - 0.02% (3)
sequence, - 0.02% (3)
easier - 0.02% (3)
internally, - 0.02% (3)
never - 0.02% (3)
identical - 0.02% (3)
datasheets - 0.02% (3)
easily - 0.02% (3)
backwards - 0.02% (3)
complexity - 0.02% (3)
seems - 0.02% (3)
discussion - 0.02% (3)
yields - 0.02% (3)
rss - 0.02% (3)
feed. - 0.02% (3)
announcement - 0.02% (3)
resistors. - 0.02% (3)
flip - 0.02% (3)
custom - 0.02% (3)
types - 0.02% (3)
edge - 0.02% (3)
squares - 0.02% (3)
8080 - 0.02% (3)
position. - 0.02% (3)
alu, - 0.02% (3)
waiting - 0.02% (3)
repeated - 0.02% (3)
horizontal - 0.02% (3)
produced - 0.02% (3)
lookahead, - 0.02% (3)
below, - 0.02% (3)
line. - 0.02% (3)
0100 - 0.02% (3)
(not - 0.02% (3)
die. - 0.02% (3)
wonder - 0.02% (3)
"ripple - 0.02% (3)
bottom. - 0.02% (3)
1001 - 0.02% (3)
b). - 0.02% (3)
unlike - 0.02% (3)
underneath - 0.02% (3)
opened - 0.02% (3)
next, - 0.02% (3)
arithmetic-logic - 0.02% (3)
calculator - 0.02% (3)
careful - 0.02% (3)
performance, - 0.02% (3)
consequence - 0.02% (3)
run - 0.02% (3)
came - 0.02% (3)
interactive - 0.02% (3)
delay - 0.02% (3)
words. - 0.02% (3)
longer - 0.02% (3)
words, - 0.02% (3)
actually - 0.02% (3)
functions: - 0.02% (3)
rejected - 0.02% (3)
value. - 0.02% (3)
big - 0.02% (3)
operation, - 0.02% (3)
revolution - 0.02% (3)
cream - 0.02% (3)
selected - 0.02% (3)
linear-feedback - 0.02% (3)
each. - 0.02% (3)
processor's - 0.02% (3)
combinations - 0.02% (3)
obtain - 0.02% (3)
example, - 0.02% (3)
carry-in, - 0.02% (3)
brief - 0.02% (3)
particular, - 0.02% (3)
set. - 0.02% (3)
chip) - 0.02% (3)
columns - 0.02% (3)
1970, - 0.02% (3)
register, - 0.02% (3)
computed - 0.02% (3)
parallel. - 0.02% (3)
(yellow) - 0.02% (3)
capacitor. - 0.02% (3)
idea - 0.02% (3)
z80's - 0.02% (3)
t3. - 0.02% (3)
apple's - 0.02% (3)
sets - 0.02% (3)
capacitance - 0.02% (3)
pdp - 0.02% (3)
want - 0.02% (3)
compact, - 0.02% (3)
7483 - 0.02% (3)
going - 0.02% (3)
remaining - 0.02% (3)
unfortunately, - 0.02% (3)
passes - 0.02% (3)
right. - 0.02% (3)
done - 0.02% (3)
speed - 0.02% (3)
efficiently - 0.02% (3)
microscope - 0.02% (3)
step - 0.02% (3)
values. - 0.02% (3)
clever - 0.02% (3)
digital - 0.02% (3)
patterns - 0.02% (3)
chargers - 0.02% (3)
latch - 0.02% (3)
outline - 0.02% (3)
1). - 0.02% (3)
xx100xxx - 0.02% (3)
desktop - 0.02% (3)
essentially - 0.02% (3)
adders - 0.02% (3)
intelligent - 0.02% (3)
iphone - 0.02% (3)
available - 0.02% (3)
decoding - 0.02% (3)
complete - 0.02% (3)
registers. - 0.02% (3)
changes - 0.02% (3)
offered - 0.02% (3)
z80, - 0.02% (3)
static - 0.02% (3)
drop - 0.02% (3)
era, - 0.02% (3)
"8-bit - 0.02% (3)
replace - 0.02% (3)
1972 - 0.02% (3)
teardown: - 0.02% (3)
expensive - 0.02% (3)
semiconductor - 0.02% (3)
wires. - 0.02% (3)
alu's - 0.02% (3)
contains - 0.02% (3)
2200's - 0.02% (3)
causes - 0.02% (3)
supply - 0.02% (3)
source - 0.02% (3)
combining - 0.02% (3)
off, - 0.02% (3)
circle - 0.02% (3)
hydrochloric - 0.02% (3)
fundamental - 0.02% (3)
around. - 0.02% (3)
decimal - 0.02% (3)
engineered - 0.02% (3)
active-low - 0.02% (3)
multiple-emitter - 0.02% (3)
expect. - 0.02% (3)
following - 0.02% (3)
vertically - 0.02% (3)
and-or-nand - 0.02% (3)
lookahead. - 0.02% (3)
current-steering - 0.02% (3)
connections - 0.02% (3)
(green - 0.02% (3)
supporting - 0.02% (3)
out, - 0.02% (3)
layer, - 0.02% (3)
silicon, - 0.02% (3)
exclusive-or - 0.02% (3)
instruction. - 0.02% (3)
away - 0.02% (3)
strange, - 0.02% (3)
back, - 0.02% (3)
ceramic - 0.02% (3)
refreshed - 0.02% (3)
bond - 0.02% (3)
storage, - 0.02% (3)
alto - 0.02% (3)
propagated - 0.02% (3)
them. - 0.02% (3)
reveal - 0.02% (3)
scheme - 0.02% (3)
pull-up - 0.02% (3)
yielding - 0.02% (3)
ground. - 0.02% (3)
instead, - 0.02% (3)
electronics, - 0.02% (3)
analyzing - 0.02% (3)
basic - 0.02% (3)
chip. ↩ - 0.02% (3)
isn't - 0.02% (3)
sequence. - 0.02% (3)
dark - 0.02% (3)
xor. - 0.02% (3)
fine - 0.02% (3)
unit), - 0.01% (2)
laws - 0.01% (2)
different. - 0.01% (2)
comes - 0.01% (2)
terminal. - 0.01% (2)
morgan's - 0.01% (2)
reverse-engineered - 0.01% (2)
subtraction. - 0.01% (2)
opposite - 0.01% (2)
history, - 0.01% (2)
2200, - 0.01% (2)
higher-order - 0.01% (2)
computer. - 0.01% (2)
got - 0.01% (2)
version, - 0.01% (2)
8080, - 0.01% (2)
8008. - 0.01% (2)
advantage - 0.01% (2)
together, - 0.01% (2)
arm-1 - 0.01% (2)
xor. ↩ - 0.01% (2)
carry, - 0.01% (2)
is. - 0.01% (2)
argument. - 0.01% (2)
regardless - 0.01% (2)
(where - 0.01% (2)
answer - 0.01% (2)
(compared - 0.01% (2)
gate). - 0.01% (2)
acid. - 0.01% (2)
glass - 0.01% (2)
etching - 0.01% (2)
obtained - 0.01% (2)
dissolve - 0.01% (2)
otherwise - 0.01% (2)
(red). - 0.01% (2)
array - 0.01% (2)
xerox - 0.01% (2)
subtraction) - 0.01% (2)
(and, - 0.01% (2)
alus - 0.01% (2)
division - 0.01% (2)
multiplication - 0.01% (2)
fairchild - 0.01% (2)
quite - 0.01% (2)
(one - 0.01% (2)
internally. - 0.01% (2)
pdp-11 - 0.01% (2)
photograph - 0.01% (2)
transistor-transistor - 0.01% (2)
chisel, - 0.01% (2)
open. - 0.01% (2)
boiling - 0.01% (2)
package, - 0.01% (2)
not-and. - 0.01% (2)
trick - 0.01% (2)
powerful - 0.01% (2)
vax-11/780 - 0.01% (2)
collectors - 0.01% (2)
compact. - 0.01% (2)
(addition, - 0.01% (2)
7404 - 0.01% (2)
base-emitter - 0.01% (2)
difficult - 0.01% (2)
(10) - 0.01% (2)
(arithmetic/logic - 0.01% (2)
making - 0.01% (2)
2017 - 0.01% (2)
▼  - 0.01% (2)
theory - 0.01% (2)
java - 0.01% (2)
magsafe - 0.01% (2)
structure. - 0.01% (2)
quality - 0.01% (2)
usb - 0.01% (2)
place. - 0.01% (2)
dozen - 0.01% (2)
role - 0.01% (2)
library - 0.01% (2)
happens - 0.01% (2)
possibly - 0.01% (2)
routing - 0.01% (2)
history. - 0.01% (2)
negative - 0.01% (2)
0.7v - 0.01% (2)
boards - 0.01% (2)
current. - 0.01% (2)
q2b - 0.01% (2)
output. - 0.01% (2)
suppose - 0.01% (2)
2^4 - 0.01% (2)
s0-s3 - 0.01% (2)
set: - 0.01% (2)
integrated - 0.01% (2)
xor) - 0.01% (2)
stripes - 0.01% (2)
version.) - 0.01% (2)
found - 0.01% (2)
minus - 0.01% (2)
what's - 0.01% (2)
increment - 0.01% (2)
base. - 0.01% (2)
changes. - 0.01% (2)
couple - 0.01% (2)
doing - 0.01% (2)
generated. - 0.01% (2)
x86. - 0.01% (2)
including - 0.01% (2)
mismatch, - 0.01% (2)
obvious - 0.01% (2)
functions.) - 0.01% (2)
load - 0.01% (2)
inputs, - 0.01% (2)
normally - 0.01% (2)
q2a - 0.01% (2)
variety - 0.01% (2)
emitters. - 0.01% (2)
4-input - 0.01% (2)
five - 0.01% (2)
hacker - 0.01% (2)
extended - 0.01% (2)
bases - 0.01% (2)
(below) - 0.01% (2)
matched - 0.01% (2)
explicit - 0.01% (2)
green. - 0.01% (2)
randomly - 0.01% (2)
f(a,b). - 0.01% (2)
throw - 0.01% (2)
highlighted. - 0.01% (2)
q2's - 0.01% (2)
steered - 0.01% (2)
acting - 0.01% (2)
inverted. - 0.01% (2)
apparently - 0.01% (2)
boxes. - 0.01% (2)
inverter. - 0.01% (2)
oversimplified - 0.01% (2)
(this - 0.01% (2)
causing - 0.01% (2)
photo, - 0.01% (2)
operands - 0.01% (2)
unexpected - 0.01% (2)
crosses - 0.01% (2)
yellowish - 0.01% (2)
photos: - 0.01% (2)
years - 0.01% (2)
undoped - 0.01% (2)
itself - 0.01% (2)
looking - 0.01% (2)
understanding - 0.01% (2)
needs - 0.01% (2)
counter, - 0.01% (2)
reading - 0.01% (2)
figured - 0.01% (2)
larger, - 0.01% (2)
conduct, - 0.01% (2)
ram, - 0.01% (2)
computer's - 0.01% (2)
lost. - 0.01% (2)
ways, - 0.01% (2)
microseconds, - 0.01% (2)
on-chip - 0.01% (2)
calls, - 0.01% (2)
connects - 0.01% (2)
storing - 0.01% (2)
turned - 0.01% (2)
voltage, - 0.01% (2)
value, - 0.01% (2)
line, - 0.01% (2)
oxide - 0.01% (2)
transistor. - 0.01% (2)
stack, - 0.01% (2)
by-sa - 0.01% (2)
(some - 0.01% (2)
contrast - 0.01% (2)
then, - 0.01% (2)
outputs, - 0.01% (2)
74ls83 - 0.01% (2)
architecture, - 0.01% (2)
interested - 0.01% (2)
requiring - 0.01% (2)
drive - 0.01% (2)
follows: - 0.01% (2)
poil - 0.01% (2)
wikimedia, - 0.01% (2)
3.0, - 0.01% (2)
thesis - 0.01% (2)
labeling - 0.01% (2)
outputs. - 0.01% (2)
activate - 0.01% (2)
reversed - 0.01% (2)
i'm - 0.01% (2)
describing - 0.01% (2)
8008) - 0.01% (2)
active-high - 0.01% (2)
memory, - 0.01% (2)
interface - 0.01% (2)
wiring, - 0.01% (2)
gray - 0.01% (2)
presentation - 0.01% (2)
(low - 0.01% (2)
highly - 0.01% (2)
sequential - 0.01% (2)
subsequence - 0.01% (2)
allows - 0.01% (2)
board, - 0.01% (2)
left. - 0.01% (2)
courtesy - 0.01% (2)
memory. - 0.01% (2)
placed - 0.01% (2)
last - 0.01% (2)
3-bit - 0.01% (2)
bits. - 0.01% (2)
up/down - 0.01% (2)
underlined - 0.01% (2)
stack; - 0.01% (2)
asked - 0.01% (2)
latches - 0.01% (2)
whole - 0.01% (2)
order, - 0.01% (2)
keeping - 0.01% (2)
various - 0.01% (2)
entries - 0.01% (2)
completed - 0.01% (2)
decided - 0.01% (2)
sell - 0.01% (2)
general-purpose - 0.01% (2)
improved - 0.01% (2)
16-bit - 0.01% (2)
8086, - 0.01% (2)
today. - 0.01% (2)
complex, - 0.01% (2)
arrows). - 0.01% (2)
magnified. - 0.01% (2)
entitled - 0.01% (2)
bit.) - 0.01% (2)
(there - 0.01% (2)
outside - 0.01% (2)
t1, - 0.01% (2)
3500 - 0.01% (2)
(white). - 0.01% (2)
stores - 0.01% (2)
enable - 0.01% (2)
14-bit - 0.01% (2)
public - 0.01% (2)
cells - 0.01% (2)
six - 0.01% (2)
dram. - 0.01% (2)
down, - 0.01% (2)
wanted - 0.01% (2)
time, - 0.01% (2)
primarily - 0.01% (2)
examined - 0.01% (2)
chip." - 0.01% (2)
studied - 0.01% (2)
$200 - 0.01% (2)
designing - 0.01% (2)
that, - 0.01% (2)
complex. - 0.01% (2)
consisting - 0.01% (2)
up. - 0.01% (2)
(purple - 0.01% (2)
announced - 0.01% (2)
wasn't - 0.01% (2)
complicated. - 0.01% (2)
resistor" - 0.01% (2)
modified - 0.01% (2)
f(1,1) - 0.01% (2)
(for - 0.01% (2)
easy - 0.01% (2)
directly - 0.01% (2)
gates: - 0.01% (2)
table, - 0.01% (2)
results - 0.01% (2)
gives - 0.01% (2)
map - 0.01% (2)
impurities - 0.01% (2)
wafer - 0.01% (2)
arguments. - 0.01% (2)
f(1,0) - 0.01% (2)
volts) - 0.01% (2)
(+5 - 0.01% (2)
vcc - 0.01% (2)
hard - 0.01% (2)
off. - 0.01% (2)
importantly - 0.01% (2)
(which - 0.01% (2)
circuitry, - 0.01% (2)
0000 - 0.01% (2)
features - 0.01% (2)
arrangement. - 0.01% (2)
layout. - 0.01% (2)
fit - 0.01% (2)
section. - 0.01% (2)
strips - 0.01% (2)
irregular - 0.01% (2)
can't - 0.01% (2)
two's - 0.01% (2)
rotating - 0.01% (2)
xx100xxx, - 0.01% (2)
opcode - 0.01% (2)
pla. - 0.01% (2)
pattern, - 0.01% (2)
produces - 0.01% (2)
(c0 - 0.01% (2)
illustrates - 0.01% (2)
m1, - 0.01% (2)
gets - 0.01% (2)
carefully - 0.01% (2)
(details). - 0.01% (2)
inside. - 0.01% (2)
extending - 0.01% (2)
interestingly, - 0.01% (2)
supported - 0.01% (2)
disable - 0.01% (2)
adder, - 0.01% (2)
depends - 0.01% (2)
correct - 0.01% (2)
inverting - 0.01% (2)
cases. - 0.01% (2)
slice, - 0.01% (2)
(since - 0.01% (2)
f(0,0) - 0.01% (2)
f(0,1) - 0.01% (2)
blocks - 0.01% (2)
pointer - 0.01% (2)
wrote - 0.01% (2)
customer - 0.01% (2)
tms - 0.01% (2)
seen - 0.01% (2)
length. - 0.01% (2)
magic-1 - 0.01% (2)
(using - 0.01% (2)
nonlinear-feedback - 0.01% (2)
2n-1 - 0.01% (2)
74f381), - 0.01% (2)
generators - 0.01% (2)
trex, - 0.01% (2)
familiar - 0.01% (2)
abandoned - 0.01% (2)
largely - 0.01% (2)
apollo181 - 0.01% (2)
mess - 0.01% (2)
too. - 0.01% (2)
2200. ↩ - 0.01% (2)
amount - 0.01% (2)
wires. ↩ - 0.01% (2)
compatible - 0.01% (2)
faster - 0.01% (2)
market - 0.01% (2)
technique - 0.01% (2)
number. - 0.01% (2)
technology, - 0.01% (2)
3101. - 0.01% (2)
look-ahead - 0.01% (2)
fourbit - 0.01% (2)
times. - 0.01% (2)
bit-slice - 0.01% (2)
accumulator - 0.01% (2)
detail, - 0.01% (2)
pretty - 0.01% (2)
construction - 0.01% (2)
left, - 0.01% (2)
been - 0.01% (2)
right, - 0.01% (2)
concept - 0.01% (2)
both). - 0.01% (2)
checks - 0.01% (2)
edges - 0.01% (2)
examines - 0.01% (2)
pads - 0.01% (2)
(note - 0.01% (2)
now.2 - 0.01% (2)
explanation - 0.01% (2)
family - 0.01% (2)
ancestor - 0.01% (2)
historically - 0.01% (2)
increase - 0.01% (2)
advanced - 0.01% (2)
manual - 0.01% (2)
closely - 0.01% (2)
consists - 0.01% (2)
data. - 0.01% (2)
hidden - 0.01% (2)
original - 0.01% (2)
amplifier - 0.01% (2)
inverts - 0.01% (2)
(22) - 0.01% (2)
of the - 1.07% (147)
the 8008 - 0.74% (102)
the 74181 - 0.63% (87)
to the - 0.51% (70)
in the - 0.5% (68)
the chip - 0.47% (64)
on the - 0.47% (64)
and the - 0.36% (49)
the alu - 0.32% (44)
the carry - 0.32% (44)
the data - 0.3% (41)
at the - 0.25% (34)
is the - 0.25% (34)
or the - 0.25% (34)
from the - 0.23% (32)
the 8008's - 0.23% (32)
for the - 0.22% (30)
die photo - 0.21% (29)
the stack - 0.2% (28)
the die - 0.2% (27)
with a - 0.19% (26)
(1) ►  - 0.19% (26)
datapoint 2200 - 0.18% (25)
the circuit - 0.18% (25)
and gate - 0.16% (22)
can be - 0.16% (22)
the datapoint - 0.16% (22)
the transistor - 0.15% (21)
the metal - 0.15% (21)
how the - 0.15% (21)
with the - 0.15% (20)
if you - 0.15% (20)
as the - 0.15% (20)
a carry - 0.14% (19)
carry lookahead - 0.14% (19)
alu chip - 0.13% (18)
74181 alu - 0.13% (18)
(2) ►  - 0.13% (18)
the instruction - 0.13% (18)
the logic - 0.12% (17)
the bit - 0.12% (17)
the first - 0.12% (16)
the output - 0.12% (16)
the right - 0.12% (16)
each bit - 0.12% (16)
die photos - 0.12% (16)
the schematic - 0.12% (16)
shift register - 0.11% (15)
by the - 0.11% (15)
a plus - 0.11% (15)
data bus - 0.11% (15)
rather than - 0.1% (14)
full adder - 0.1% (14)
there is - 0.1% (14)
the 74181's - 0.1% (14)
logic functions - 0.1% (14)
are the - 0.1% (14)
74181 chip - 0.1% (14)
connected to - 0.1% (14)
the sum - 0.1% (14)
in parallel - 0.1% (14)
alu slice - 0.09% (13)
metal layer - 0.09% (13)
if the - 0.09% (13)
the two - 0.09% (13)
8008's alu - 0.09% (13)
which i - 0.09% (13)
the chip. - 0.09% (13)
bit is - 0.09% (13)
(3) ►  - 0.09% (13)
the other - 0.09% (13)
for each - 0.09% (13)
using the - 0.09% (12)
that the - 0.09% (12)
the 8008, - 0.09% (12)
you can - 0.09% (12)
since the - 0.09% (12)
the de - 0.09% (12)
the and - 0.09% (12)
the result - 0.08% (11)
thus, the - 0.08% (11)
which is - 0.08% (11)
control line - 0.08% (11)
the value - 0.08% (11)
one of - 0.08% (11)
or and - 0.08% (11)
and gates - 0.08% (11)
the second - 0.08% (11)
such as - 0.08% (11)
there are - 0.08% (11)
the inverter - 0.08% (11)
uses a - 0.08% (11)
the left - 0.08% (11)
8008 microprocessor - 0.08% (11)
chip is - 0.08% (11)
below shows - 0.08% (11)
the diagram - 0.08% (11)
the top - 0.08% (11)
the gate - 0.07% (10)
a single - 0.07% (10)
transistors are - 0.07% (10)
the same - 0.07% (10)
logic operations - 0.07% (10)
sense line - 0.07% (10)
line is - 0.07% (10)
generate the - 0.07% (10)
the transistors - 0.07% (10)
the arithmetic - 0.07% (10)
lookahead circuit - 0.07% (10)
it for - 0.07% (10)
between the - 0.07% (10)
build a - 0.07% (10)
and-or-invert gate - 0.07% (10)
inside the - 0.07% (10)
the carry-in - 0.07% (10)
chip. the - 0.07% (10)
the input - 0.07% (10)
this is - 0.07% (10)
the base - 0.07% (10)
from a - 0.07% (10)
used in - 0.07% (10)
arithmetic functions - 0.07% (9)
the 16 - 0.07% (9)
►  march - 0.07% (9)
the photo - 0.07% (9)
the or - 0.07% (9)
the silicon - 0.07% (9)
used to - 0.07% (9)
diagram below - 0.07% (9)
logic unit - 0.07% (9)
is that - 0.07% (9)
part of - 0.07% (9)
through the - 0.07% (9)
feedback shift - 0.07% (9)
instruction set - 0.07% (9)
but the - 0.07% (9)
►  february - 0.07% (9)
stack storage - 0.07% (9)
the alu. - 0.07% (9)
the next - 0.06% (8)
doped silicon - 0.06% (8)
implemented with - 0.06% (8)
an inverter - 0.06% (8)
is used - 0.06% (8)
control signal - 0.06% (8)
the collector - 0.06% (8)
can see - 0.06% (8)
so the - 0.06% (8)
the processor - 0.06% (8)
instruction decode - 0.06% (8)
instead of - 0.06% (8)
(4) ►  - 0.06% (8)
bit of - 0.06% (8)
you might - 0.06% (8)
nand gate - 0.06% (8)
the carry-out - 0.06% (8)
and logic - 0.06% (8)
functions are - 0.06% (8)
the circuitry - 0.06% (8)
the full - 0.06% (8)
boolean function - 0.06% (8)
have a - 0.06% (8)
alu circuit - 0.06% (8)
used a - 0.06% (8)
to compute - 0.06% (8)
see the - 0.06% (8)
uses the - 0.06% (8)
carry-lookahead circuit - 0.05% (7)
and-or-invert gates - 0.05% (7)
side of - 0.05% (7)
nor gate - 0.05% (7)
8008 is - 0.05% (7)
a full - 0.05% (7)
is low - 0.05% (7)
transistors in - 0.05% (7)
data bus. - 0.05% (7)
carry out - 0.05% (7)
since i - 0.05% (7)
by using - 0.05% (7)
are implemented - 0.05% (7)
plus f - 0.05% (7)
to perform - 0.05% (7)
other hand, - 0.05% (7)
will be - 0.05% (7)
the carries - 0.05% (7)
note that - 0.05% (7)
are connected - 0.05% (7)
built from - 0.05% (7)
circuit is - 0.05% (7)
adder circuit - 0.05% (7)
logic is - 0.05% (7)
►  december - 0.05% (7)
similar to - 0.05% (7)
each row - 0.05% (7)
4 bits - 0.05% (7)
is implemented - 0.05% (7)
8008 processor - 0.05% (7)
the sense - 0.05% (7)
►  may - 0.05% (7)
and instruction - 0.05% (7)
for high - 0.05% (7)
gates are - 0.05% (7)
bit pattern - 0.05% (7)
ttl chip - 0.05% (7)
to build - 0.05% (7)
8008 uses - 0.05% (7)
around the - 0.05% (7)
chip in - 0.05% (7)
the three - 0.04% (6)
and write - 0.04% (6)
it. in - 0.04% (6)
turn on - 0.04% (6)
npn transistor - 0.04% (6)
the gates - 0.04% (6)
more complex - 0.04% (6)
the chip's - 0.04% (6)
before the - 0.04% (6)
g with - 0.04% (6)
shows the - 0.04% (6)
transistors and - 0.04% (6)
the bottom - 0.04% (6)
g signals - 0.04% (6)
the intel - 0.04% (6)
the microprocessor - 0.04% (6)
unit (alu) - 0.04% (6)
chip a - 0.04% (6)
this article - 0.04% (6)
the emitter - 0.04% (6)
based on - 0.04% (6)
is stored - 0.04% (6)
the polysilicon - 0.04% (6)
the four - 0.04% (6)
de bruijn - 0.04% (6)
bruijn sequence - 0.04% (6)
input is - 0.04% (6)
a large - 0.04% (6)
to generate - 0.04% (6)
form a - 0.04% (6)
one bit - 0.04% (6)
bits are - 0.04% (6)
y. the - 0.04% (6)
than the - 0.04% (6)
pulls the - 0.04% (6)
►  april - 0.04% (6)
if you're - 0.04% (6)
they are - 0.04% (6)
or gates - 0.04% (6)
it works - 0.04% (6)
texas instruments - 0.04% (6)
for instance, - 0.04% (6)
compared to - 0.04% (6)
way to - 0.04% (6)
however, the - 0.04% (6)
the die, - 0.04% (6)
to understand - 0.04% (6)
a different - 0.04% (6)
or this - 0.04% (6)
out of - 0.04% (6)
must be - 0.04% (6)
like a - 0.04% (6)
how it - 0.04% (6)
the vintage - 0.04% (6)
from bit - 0.04% (6)
is set - 0.04% (6)
how to - 0.04% (6)
there's a - 0.04% (6)
intel 8008 - 0.04% (6)
►  august - 0.04% (5)
turns on - 0.04% (5)
was the - 0.04% (5)
►  june - 0.04% (5)
silicon die - 0.04% (5)
alu operation - 0.04% (5)
connecting the - 0.04% (5)
photo of - 0.04% (5)
in this - 0.04% (5)
layer is - 0.04% (5)
alu slices - 0.04% (5)
silicon layer - 0.04% (5)
the register - 0.04% (5)
it. the - 0.04% (5)
circuit for - 0.04% (5)
boolean functions - 0.04% (5)
new bit - 0.04% (5)
information on - 0.04% (5)
the 4004 - 0.04% (5)
the 74181, - 0.04% (5)
to use - 0.04% (5)
be used - 0.04% (5)
►  july - 0.04% (5)
logical operations - 0.04% (5)
and or - 0.04% (5)
16 possible - 0.04% (5)
the operation - 0.04% (5)
►  january - 0.04% (5)
mode lines - 0.04% (5)
plus f(a,b) - 0.04% (5)
are in - 0.04% (5)
"a plus - 0.04% (5)
schematic below - 0.04% (5)
inside a - 0.04% (5)
boolean logic - 0.04% (5)
well as - 0.04% (5)
is pulled - 0.04% (5)
where a - 0.04% (5)
chip to - 0.04% (5)
it the - 0.04% (5)
a switch - 0.04% (5)
►  november - 0.04% (5)
metal wiring - 0.04% (5)
is based - 0.04% (5)
►  october - 0.04% (5)
and so - 0.04% (5)
a high - 0.04% (5)
although the - 0.04% (5)
the addition - 0.04% (5)
and are - 0.04% (5)
but not - 0.04% (5)
shows how - 0.04% (5)
gate is - 0.04% (5)
photos and - 0.04% (5)
chip was - 0.04% (5)
the 74181. - 0.04% (5)
to implement - 0.04% (5)
the stack. - 0.04% (5)
generates the - 0.04% (5)
if there - 0.04% (5)
any of - 0.04% (5)
the bits - 0.04% (5)
called the - 0.04% (5)
circuit to - 0.04% (5)
is not - 0.04% (5)
have an - 0.04% (5)
the pla - 0.04% (5)
and generate - 0.04% (5)
the low - 0.04% (5)
is low, - 0.04% (5)
blog post - 0.04% (5)
but if - 0.04% (5)
december (2) - 0.04% (5)
to see - 0.04% (5)
to turn - 0.04% (5)
the control - 0.04% (5)
but in - 0.04% (5)
1. the - 0.04% (5)
the and-or-invert - 0.04% (5)
nonlinear feedback - 0.04% (5)
as well - 0.04% (5)
carry to - 0.04% (5)
of gates - 0.04% (5)
each column - 0.04% (5)
for this - 0.04% (5)
top of - 0.04% (5)
march 13, - 0.03% (4)
arithmetic and - 0.03% (4)
to pinterest - 0.03% (4)
the image - 0.03% (4)
for its - 0.03% (4)
datapoint 2200. - 0.03% (4)
just a - 0.03% (4)
to count - 0.03% (4)
explain how - 0.03% (4)
silicon region - 0.03% (4)
minicomputers built - 0.03% (4)
from die - 0.03% (4)
a shift - 0.03% (4)
two transistors - 0.03% (4)
chip uses - 0.03% (4)
the or-invert - 0.03% (4)
shifted to - 0.03% (4)
output low. - 0.03% (4)
the current - 0.03% (4)
are highlighted - 0.03% (4)
processor board - 0.03% (4)
pulled low - 0.03% (4)
feature of - 0.03% (4)
tmc 1795 - 0.03% (4)
the tmc - 0.03% (4)
image below - 0.03% (4)
but it - 0.03% (4)
sequence of - 0.03% (4)
it can - 0.03% (4)
the ti - 0.03% (4)
introduced the - 0.03% (4)
parts of - 0.03% (4)
8008 chip - 0.03% (4)
so forth. - 0.03% (4)
an xor - 0.03% (4)
the i3101 - 0.03% (4)
bit to - 0.03% (4)
with an - 0.03% (4)
the inputs - 0.03% (4)
external pins. - 0.03% (4)
into the - 0.03% (4)
for an - 0.03% (4)
two input - 0.03% (4)
sum bit - 0.03% (4)
gate in - 0.03% (4)
implemented by - 0.03% (4)
to support - 0.03% (4)
gates and - 0.03% (4)
a transistor - 0.03% (4)
control signals - 0.03% (4)
has the - 0.03% (4)
to simplify - 0.03% (4)
most of - 0.03% (4)
early microprocessor - 0.03% (4)
all the - 0.03% (4)
in most - 0.03% (4)
logic operations. - 0.03% (4)
operations are - 0.03% (4)
for higher - 0.03% (4)
the chip, - 0.03% (4)
parallel processor - 0.03% (4)
up the - 0.03% (4)
post email - 0.03% (4)
silicon is - 0.03% (4)
8008 has - 0.03% (4)
shift-register counter - 0.03% (4)
comments: links - 0.03% (4)
are not - 0.03% (4)
arithmetic/logic unit - 0.03% (4)
to this - 0.03% (4)
c. the - 0.03% (4)
used as - 0.03% (4)
stored on - 0.03% (4)
thisblogthis!share to - 0.03% (4)
twittershare to - 0.03% (4)
facebookshare to - 0.03% (4)
pinterest labels: - 0.03% (4)
the appropriate - 0.03% (4)
turning on - 0.03% (4)
the doped - 0.03% (4)
transistor is - 0.03% (4)
this was - 0.03% (4)
reason for - 0.03% (4)
in electronics - 0.03% (4)
used for - 0.03% (4)
to twittershare - 0.03% (4)
reverse-engineer the - 0.03% (4)
die photos, - 0.03% (4)
the signal - 0.03% (4)
due to - 0.03% (4)
pulling the - 0.03% (4)
controlled by - 0.03% (4)
control lines - 0.03% (4)
via the - 0.03% (4)
to ground - 0.03% (4)
an alu - 0.03% (4)
the underlying - 0.03% (4)
while the - 0.03% (4)
generating a - 0.03% (4)
to facebookshare - 0.03% (4)
a processor - 0.03% (4)
email thisblogthis!share - 0.03% (4)
layer of - 0.03% (4)
it was - 0.03% (4)
inputs are - 0.03% (4)
along the - 0.03% (4)
top and - 0.03% (4)
select the - 0.03% (4)
under the - 0.03% (4)
finally, the - 0.03% (4)
is generated - 0.03% (4)
chip. i - 0.03% (4)
is similar - 0.03% (4)
gates. the - 0.03% (4)
alu chip. - 0.03% (4)
a complex - 0.03% (4)
use the - 0.03% (4)
functions and - 0.03% (4)
announce my - 0.03% (4)
latest blog - 0.03% (4)
posts on - 0.03% (4)
twitter, so - 0.03% (4)
follow me - 0.03% (4)
at kenshirriff. - 0.03% (4)
notes and - 0.03% (4)
many minicomputers - 0.03% (4)
and then - 0.03% (4)
a generate - 0.03% (4)
is almost - 0.03% (4)
this post - 0.03% (4)
output bit - 0.03% (4)
schematic is - 0.03% (4)
and why - 0.03% (4)
►  september - 0.03% (4)
these are - 0.03% (4)
16 logic - 0.03% (4)
arithmetic operations - 0.03% (4)
alu chip: - 0.03% (4)
is, the - 0.03% (4)
plus carry-in. - 0.03% (4)
april (1) - 0.03% (4)
logical function - 0.03% (4)
may (2) - 0.03% (4)
even though - 0.03% (4)
march (1) - 0.03% (4)
result is - 0.03% (4)
creating the - 0.03% (4)
(5) ►  - 0.03% (4)
may seem - 0.03% (4)
generate a - 0.03% (4)
there's no - 0.03% (4)
charger teardown - 0.03% (4)
g (generate) - 0.03% (4)
p (propagate) - 0.03% (4)
the 7451 - 0.03% (4)
generated from - 0.03% (4)
the table - 0.03% (4)
sum. the - 0.03% (4)
is added - 0.03% (4)
chip with - 0.03% (4)
a simple - 0.03% (4)
at first - 0.03% (4)
operation to - 0.03% (4)
links to - 0.03% (4)
high, the - 0.03% (4)
output is - 0.03% (4)
circuit used - 0.03% (4)
to provide - 0.02% (3)
you'd expect - 0.02% (3)
the standard - 0.02% (3)
ram chips - 0.02% (3)
more important - 0.02% (3)
values are - 0.02% (3)
 ↩ a - 0.02% (3)
described in - 0.02% (3)
as much - 0.02% (3)
inverter chip - 0.02% (3)
why the - 0.02% (3)
the popular - 0.02% (3)
8008's internal - 0.02% (3)
you look - 0.02% (3)
not an - 0.02% (3)
bits of - 0.02% (3)
4-bit alu - 0.02% (3)
8008, the - 0.02% (3)
offered on - 0.02% (3)
computes the - 0.02% (3)
gates by - 0.02% (3)
the address - 0.02% (3)
electronics on - 0.02% (3)
in parallel, - 0.02% (3)
in particular, - 0.02% (3)
in minicomputer - 0.02% (3)
eight different - 0.02% (3)
or, and - 0.02% (3)
counter to - 0.02% (3)
stack counter - 0.02% (3)
out from - 0.02% (3)
output transistor - 0.02% (3)
generated by - 0.02% (3)
match the - 0.02% (3)
addition, subtraction, - 0.02% (3)
the truth - 0.02% (3)
xor, a - 0.02% (3)
used by - 0.02% (3)
pull the - 0.02% (3)
can generate - 0.02% (3)
a lfsr - 0.02% (3)
output high. - 0.02% (3)
linear-feedback shift - 0.02% (3)
a pmos - 0.02% (3)
the ttl - 0.02% (3)
be computed - 0.02% (3)
lines are - 0.02% (3)
rss feed. - 0.02% (3)
simplified the - 0.02% (3)
left side - 0.02% (3)
see how - 0.02% (3)
74181 work - 0.02% (3)
two inputs - 0.02% (3)
strange, but - 0.02% (3)
bus. the - 0.02% (3)
operation is - 0.02% (3)
lines. the - 0.02% (3)
signals are - 0.02% (3)
is connected - 0.02% (3)
it more - 0.02% (3)
bits on - 0.02% (3)
in parallel. - 0.02% (3)
where the - 0.02% (3)
you have - 0.02% (3)
to make - 0.02% (3)
hydrochloric acid - 0.02% (3)
performance, the - 0.02% (3)
right side - 0.02% (3)
space on - 0.02% (3)
what operation - 0.02% (3)
with multiple - 0.02% (3)
doped silicon. - 0.02% (3)
compute the - 0.02% (3)
half of - 0.02% (3)
carry chain - 0.02% (3)
few gates - 0.02% (3)
transistors that - 0.02% (3)
and information - 0.02% (3)
vintage 74181 - 0.02% (3)
signals for - 0.02% (3)
previous article - 0.02% (3)
each bit, - 0.02% (3)
and generates - 0.02% (3)
many minicomputers. - 0.02% (3)
counter is - 0.02% (3)
full 4-bit - 0.02% (3)
in more - 0.02% (3)
turns on, - 0.02% (3)
this article, - 0.02% (3)
by examining - 0.02% (3)
signal is - 0.02% (3)
xor gates - 0.02% (3)
all to - 0.02% (3)
a signal - 0.02% (3)
a collector, - 0.02% (3)
the right. - 0.02% (3)
bit sum - 0.02% (3)
pmos transistor - 0.02% (3)
passes through - 0.02% (3)
clock cycles - 0.02% (3)
the sum. - 0.02% (3)
alu to - 0.02% (3)
here. the - 0.02% (3)
the xor - 0.02% (3)
february (1) - 0.02% (3)
make up - 0.02% (3)
gates that - 0.02% (3)
behind the - 0.02% (3)
active-low logic - 0.02% (3)
causes the - 0.02% (3)
many of - 0.02% (3)
as shown - 0.02% (3)
will always - 0.02% (3)
removing the - 0.02% (3)
instruction bit - 0.02% (3)
and logical - 0.02% (3)
how they - 0.02% (3)
low, and - 0.02% (3)
circuitry is - 0.02% (3)
shows a - 0.02% (3)
instruction decoder - 0.02% (3)
arranged in - 0.02% (3)
processors, the - 0.02% (3)
and with - 0.02% (3)
b plus - 0.02% (3)
might wonder - 0.02% (3)
system behind - 0.02% (3)
a logical - 0.02% (3)
and and - 0.02% (3)
does it - 0.02% (3)
is simply - 0.02% (3)
forcing the - 0.02% (3)
functions of - 0.02% (3)
logic operations, - 0.02% (3)
adder is - 0.02% (3)
bizarre functions - 0.02% (3)
transistor turns - 0.02% (3)
the eight - 0.02% (3)
z80's alu - 0.02% (3)
for example, - 0.02% (3)
three input - 0.02% (3)
complex gate - 0.02% (3)
and, or, - 0.02% (3)
form an - 0.02% (3)
xor and - 0.02% (3)
to select - 0.02% (3)
you get - 0.02% (3)
the alu's - 0.02% (3)
shown in - 0.02% (3)
alu is - 0.02% (3)
a second - 0.02% (3)
important because - 0.02% (3)
there will - 0.02% (3)
on one - 0.02% (3)
the chip) - 0.02% (3)
power supply - 0.02% (3)
charger teardown: - 0.02% (3)
chip: how - 0.02% (3)
idea of - 0.02% (3)
alu chip, - 0.02% (3)
electronics, reverse-engineering - 0.02% (3)
my previous - 0.02% (3)
is all - 0.02% (3)
because it - 0.02% (3)
8008 was - 0.02% (3)
discussion of - 0.02% (3)
of its - 0.02% (3)
build an - 0.02% (3)
arithmetic-logic unit - 0.02% (3)
on march - 0.02% (3)
each t - 0.02% (3)
machine cycle - 0.02% (3)
each machine - 0.02% (3)
implements a - 0.02% (3)
schematic of - 0.02% (3)
article, i - 0.02% (3)
bit position - 0.02% (3)
b) plus - 0.02% (3)
temporary registers - 0.02% (3)
set of - 0.02% (3)
unusual feature - 0.02% (3)
bits in - 0.02% (3)
waiting for - 0.02% (3)
the column - 0.02% (3)
is carry - 0.02% (3)
performed by - 0.02% (3)
processor from - 0.02% (3)
implements the - 0.02% (3)
march (2) - 0.02% (3)
is important - 0.02% (3)
vintage 8008 - 0.02% (3)
second number - 0.02% (3)
resulting in - 0.02% (3)
set in - 0.02% (3)
probably using - 0.02% (3)
its complex - 0.02% (3)
analyzing the - 0.02% (3)
a detailed - 0.02% (3)
a programmable - 0.02% (3)
acts as - 0.02% (3)
i also - 0.02% (3)
each carry - 0.02% (3)
base to - 0.02% (3)
of many - 0.02% (3)
structure of - 0.02% (3)
an npn - 0.02% (3)
ic. the - 0.02% (3)
collector and - 0.02% (3)
two bits - 0.02% (3)
multiple 74181 - 0.02% (3)
74181 implements - 0.02% (3)
carry from - 0.02% (3)
alu that - 0.02% (3)
and emitter - 0.02% (3)
ttl logic - 0.02% (3)
i'll explain - 0.02% (3)
a pseudo-random - 0.02% (3)
a nonlinear - 0.02% (3)
chip works - 0.02% (3)
and how - 0.02% (3)
track of - 0.02% (3)
dynamic ram - 0.02% (3)
to its - 0.02% (3)
it provides - 0.02% (3)
of storage - 0.02% (3)
is designed - 0.02% (3)
silicon regions - 0.02% (3)
that make - 0.02% (3)
take the - 0.02% (3)
to create - 0.02% (3)
a metal - 0.02% (3)
nand gate. - 0.02% (3)
fast carry - 0.02% (3)
if you've - 0.02% (3)
the mos - 0.02% (3)
connected by - 0.02% (3)
refresh counter - 0.02% (3)
internal stack - 0.02% (3)
inverter in - 0.02% (3)
8008 microprocessor, - 0.02% (3)
the edge - 0.02% (3)
the chips - 0.02% (3)
are inverted, - 0.02% (3)
the layout - 0.02% (3)
select input - 0.02% (3)
logic functions, - 0.02% (3)
is very - 0.02% (3)
in red. - 0.02% (3)
multiple emitters - 0.02% (3)
it uses - 0.02% (3)
datapoint 2200's - 0.02% (3)
current will - 0.02% (3)
and not - 0.02% (3)
an interesting - 0.02% (3)
intelligent terminal - 0.02% (3)
8008 as - 0.02% (3)
processor offered - 0.02% (3)
"8-bit parallel - 0.02% (3)
stored in - 0.02% (3)
easier to - 0.02% (3)
stack is - 0.02% (3)
single chip. - 0.02% (3)
die, i - 0.02% (3)
along with - 0.02% (3)
r1's current - 0.02% (3)
datapoint rejected - 0.02% (3)
logic in - 0.02% (3)
of simple - 0.02% (3)
showing the - 0.02% (3)
onto a - 0.02% (3)
program counter - 0.02% (3)
chip that - 0.02% (3)
identical to - 0.02% (3)
story of - 0.02% (3)
stack. the - 0.02% (3)
write the - 0.02% (3)
subroutine call - 0.02% (3)
simply the - 0.02% (3)
row is - 0.02% (3)
(such as - 0.02% (3)
a system - 0.02% (3)
bond wires - 0.02% (3)
lines in - 0.02% (3)
the desired - 0.02% (3)
to form - 0.02% (3)
behind it. - 0.02% (3)
is performed - 0.02% (3)
and resistors - 0.02% (3)
is built - 0.02% (3)
read and - 0.02% (3)
hand, if - 0.02% (3)
to write - 0.02% (3)
instance, the - 0.02% (3)
to read - 0.02% (3)
and outputs - 0.02% (3)
the 7483 - 0.02% (3)
and reverse - 0.02% (3)
that is - 0.02% (3)
functions, as - 0.02% (3)
die to - 0.02% (3)
and is - 0.02% (3)
pins. the - 0.02% (3)
to find - 0.02% (3)
that there - 0.02% (3)
the subtract - 0.02% (3)
july (3) - 0.01% (2)
that implement - 0.01% (2)
decoded on - 0.01% (2)
may (1) - 0.01% (2)
match bit - 0.01% (2)
requires a - 0.01% (2)
of transistors - 0.01% (2)
to ripple - 0.01% (2)
its complexity - 0.01% (2)
carry generator - 0.01% (2)
adder circuit. - 0.01% (2)
that are - 0.01% (2)
the meaning - 0.01% (2)
you've probably - 0.01% (2)
read the - 0.01% (2)
lower half - 0.01% (2)
compute xor - 0.01% (2)
a chisel, - 0.01% (2)
of each - 0.01% (2)
perform subtraction - 0.01% (2)
take up - 0.01% (2)
programmable logic - 0.01% (2)
the temporary - 0.01% (2)
january (1) - 0.01% (2)
register to - 0.01% (2)
through q1's - 0.01% (2)
as long - 0.01% (2)
multiple emitters. - 0.01% (2)
individual ttl - 0.01% (2)
is wired - 0.01% (2)
history, so - 0.01% (2)
or-invert stage - 0.01% (2)
to match - 0.01% (2)
i took - 0.01% (2)
detail on - 0.01% (2)
right now.2 - 0.01% (2)
bits 3, - 0.01% (2)
x86 architecture - 0.01% (2)
acting as - 0.01% (2)
could be - 0.01% (2)
the ancestor - 0.01% (2)
left or - 0.01% (2)
emitter to - 0.01% (2)
7451 and-or-invert - 0.01% (2)
be shifted - 0.01% (2)
chip, but - 0.01% (2)
au (arithmetic - 0.01% (2)
is high, - 0.01% (2)
current to - 0.01% (2)
by putting - 0.01% (2)
works and - 0.01% (2)
shifting is - 0.01% (2)
like the - 0.01% (2)
transistors share - 0.01% (2)
which pulls - 0.01% (2)
adder chip - 0.01% (2)
are decoded - 0.01% (2)
matches a - 0.01% (2)
between a - 0.01% (2)
(details). the - 0.01% (2)
easily be - 0.01% (2)
and gates, - 0.01% (2)
high and - 0.01% (2)
octal structure - 0.01% (2)
the nor - 0.01% (2)
and of - 0.01% (2)
operations were - 0.01% (2)
february (2) - 0.01% (2)
(0 through - 0.01% (2)
are high, - 0.01% (2)
common in - 0.01% (2)
the operation. - 0.01% (2)
by adding - 0.01% (2)
operations, and - 0.01% (2)
extended to - 0.01% (2)
of this - 0.01% (2)
set is - 0.01% (2)
8008 alu - 0.01% (2)
almost always - 0.01% (2)
including the - 0.01% (2)
so strange - 0.01% (2)
the multiple-emitter - 0.01% (2)
so it's - 0.01% (2)
transistor q2 - 0.01% (2)
alu (arithmetic/logic - 0.01% (2)
second is - 0.01% (2)
by extending - 0.01% (2)
and-or-invert circuit - 0.01% (2)
first input - 0.01% (2)
inputs as - 0.01% (2)
but why - 0.01% (2)
august (1) - 0.01% (2)
november (5) - 0.01% (2)
computers of - 0.01% (2)
decoder generates - 0.01% (2)
to ground. - 0.01% (2)
stages are - 0.01% (2)
in green. - 0.01% (2)
package, which - 0.01% (2)
perform an - 0.01% (2)
alu control - 0.01% (2)
is much - 0.01% (2)
8008's instruction - 0.01% (2)
are on - 0.01% (2)
be matched - 0.01% (2)
yellow polysilicon - 0.01% (2)
vertically through - 0.01% (2)
history of - 0.01% (2)
october (3) - 0.01% (2)
to invert - 0.01% (2)
january (3) - 0.01% (2)
a ceramic - 0.01% (2)
the way - 0.01% (2)
alu operations, - 0.01% (2)
december (1) - 0.01% (2)
how this - 0.01% (2)
and instructions - 0.01% (2)
alu. the - 0.01% (2)
have the - 0.01% (2)
of and - 0.01% (2)
make the - 0.01% (2)
to and - 0.01% (2)
the m1 - 0.01% (2)
instruction to - 0.01% (2)
is described - 0.01% (2)
when the - 0.01% (2)
up with - 0.01% (2)
transistor with - 0.01% (2)
chips are - 0.01% (2)
integrated circuit - 0.01% (2)
the inverter. - 0.01% (2)
into a - 0.01% (2)
board, but - 0.01% (2)
that have - 0.01% (2)
powerful vax-11/780 - 0.01% (2)
q2 turns - 0.01% (2)
enough voltage - 0.01% (2)
implemented on - 0.01% (2)
a brief - 0.01% (2)
diode d2 - 0.01% (2)
the edges - 0.01% (2)
it implements - 0.01% (2)
npn transistors - 0.01% (2)
in one - 0.01% (2)
is slightly - 0.01% (2)
i used - 0.01% (2)
row line - 0.01% (2)
parallel for - 0.01% (2)
and carry - 0.01% (2)
four bits - 0.01% (2)
appears in - 0.01% (2)
collector, base - 0.01% (2)
or are - 0.01% (2)
pmos gate - 0.01% (2)
wikimedia, cc - 0.01% (2)
poil on - 0.01% (2)
diagram by - 0.01% (2)
highlighted in - 0.01% (2)
if any - 0.01% (2)
diode drop - 0.01% (2)
has transistors - 0.01% (2)
(compared to - 0.01% (2)
an nmos - 0.01% (2)
by one - 0.01% (2)
how an - 0.01% (2)
a 74181 - 0.01% (2)
is probably - 0.01% (2)
collector is - 0.01% (2)
come from - 0.01% (2)
these gates - 0.01% (2)
input lines - 0.01% (2)
arrangement of - 0.01% (2)
transistor q1 - 0.01% (2)
ripple carry. - 0.01% (2)
a high-resolution - 0.01% (2)
logic array - 0.01% (2)
row in - 0.01% (2)
three of - 0.01% (2)
not surprising - 0.01% (2)
equivalent to - 0.01% (2)
67 gates - 0.01% (2)
the z80, - 0.01% (2)
tiny bond - 0.01% (2)
morgan's laws - 0.01% (2)
types of - 0.01% (2)
and similarly - 0.01% (2)
much current - 0.01% (2)
the arithmetic/logic - 0.01% (2)
the basic - 0.01% (2)
is equivalent - 0.01% (2)
7404 inverter - 0.01% (2)
the not - 0.01% (2)
complex chip - 0.01% (2)
are exactly - 0.01% (2)
is possible - 0.01% (2)
may appear - 0.01% (2)
typical full - 0.01% (2)
the typical - 0.01% (2)
you want - 0.01% (2)
a control - 0.01% (2)
and emitter, - 0.01% (2)
it appears - 0.01% (2)
omit the - 0.01% (2)
particular, it - 0.01% (2)
take a - 0.01% (2)
more die - 0.01% (2)
the architecture, - 0.01% (2)
right is - 0.01% (2)
inputs. the - 0.01% (2)
the fundamental - 0.01% (2)
article has - 0.01% (2)
interested in - 0.01% (2)
carry-lookahead circuit, - 0.01% (2)
higher performance. - 0.01% (2)
image below. - 0.01% (2)
adding more - 0.01% (2)
with hydrochloric - 0.01% (2)
mismatch, the - 0.01% (2)
transistors. the - 0.01% (2)
collector to - 0.01% (2)
courtesy of - 0.01% (2)
keeping the - 0.01% (2)
used the - 0.01% (2)
computer. the - 0.01% (2)
output transistors - 0.01% (2)
was built - 0.01% (2)
inside apple's - 0.01% (2)
usb chargers - 0.01% (2)
was more - 0.01% (2)
a dozen - 0.01% (2)
it's so - 0.01% (2)
works in - 0.01% (2)
4-input or - 0.01% (2)
the 8080, - 0.01% (2)
a very - 0.01% (2)
much more - 0.01% (2)
an article - 0.01% (2)
larger words, - 0.01% (2)
simply a - 0.01% (2)
(click for - 0.01% (2)
high-resolution version.) - 0.01% (2)
in terms - 0.01% (2)
why it's - 0.01% (2)
subtraction is - 0.01% (2)
second argument. - 0.01% (2)
are used - 0.01% (2)
chip works. - 0.01% (2)
minicomputers. i - 0.01% (2)
each with - 0.01% (2)
the photo. - 0.01% (2)
layout on - 0.01% (2)
the idea - 0.01% (2)
by-sa 3.0, - 0.01% (2)
simplify routing - 0.01% (2)
the pull-up - 0.01% (2)
74181's 16 - 0.01% (2)
reverse-engineered the - 0.01% (2)
entitled "8-bit - 0.01% (2)
and determine - 0.01% (2)
using an - 0.01% (2)
current from - 0.01% (2)
low. an - 0.01% (2)
you're probably - 0.01% (2)
wonder how - 0.01% (2)
i plan - 0.01% (2)
a small - 0.01% (2)
some datasheets - 0.01% (2)
bit line - 0.01% (2)
the die. - 0.01% (2)
with standard - 0.01% (2)
transistor appears - 0.01% (2)
x86 processor - 0.01% (2)
tiny silicon - 0.01% (2)
or, the - 0.01% (2)
stack in - 0.01% (2)
this presentation - 0.01% (2)
4 comments: - 0.01% (2)
labels: electronics, - 0.01% (2)
photos: its - 0.01% (2)
unusual counters - 0.01% (2)
45 years - 0.01% (2)
i figured - 0.01% (2)
its internal - 0.01% (2)
fast ttl - 0.01% (2)
it had - 0.01% (2)
subroutine calls, - 0.01% (2)
storing the - 0.01% (2)
binary counters - 0.01% (2)
the operations - 0.01% (2)
stack, the - 0.01% (2)
using shift-register - 0.01% (2)
i reverse-engineer - 0.01% (2)
which put - 0.01% (2)
die, highly - 0.01% (2)
magnified. around - 0.01% (2)
the outside - 0.01% (2)
die, you - 0.01% (2)
the 18 - 0.01% (2)
wires connecting - 0.01% (2)
chip's external - 0.01% (2)
from about - 0.01% (2)
3500 tiny - 0.01% (2)
logic, so - 0.01% (2)
except the - 0.01% (2)
wiring layer - 0.01% (2)
as follows: - 0.01% (2)
that performs - 0.01% (2)
across multiple - 0.01% (2)
to all - 0.01% (2)
a propagate - 0.01% (2)
32 arithmetic - 0.01% (2)
the carry-lookahead - 0.01% (2)
chip provided - 0.01% (2)
and to - 0.01% (2)
appear in - 0.01% (2)
datasheets show - 0.01% (2)
while other - 0.01% (2)
terms of - 0.01% (2)
select inputs - 0.01% (2)
a diagram - 0.01% (2)
74181 works - 0.01% (2)
by poil - 0.01% (2)
on wikimedia, - 0.01% (2)
cc by-sa - 0.01% (2)
3.0, with - 0.01% (2)
circuitry and - 0.01% (2)
used with - 0.01% (2)
the subtraction - 0.01% (2)
the inverted - 0.01% (2)
are reversed - 0.01% (2)
with active-high - 0.01% (2)
logic, where - 0.01% (2)
signal indicates - 0.01% (2)
active-low logic, - 0.01% (2)
transistors (yellow) - 0.01% (2)
(alu) chip, - 0.01% (2)
one chip - 0.01% (2)
architecture that - 0.01% (2)
hold the - 0.01% (2)
no separate - 0.01% (2)
counter and - 0.01% (2)
intel and - 0.01% (2)
stack pointer - 0.01% (2)
they could - 0.01% (2)
put the - 0.01% (2)
board onto - 0.01% (2)
set and - 0.01% (2)
intel completed - 0.01% (2)
it. intel - 0.01% (2)
the x86 - 0.01% (2)
of these - 0.01% (2)
a 4-bit - 0.01% (2)
of that - 0.01% (2)
the straightforward - 0.01% (2)
implement the - 0.01% (2)
to keep - 0.01% (2)
(which is - 0.01% (2)
counter. the - 0.01% (2)
everything works - 0.01% (2)
is shown - 0.01% (2)
below. the - 0.01% (2)
yields all - 0.01% (2)
each value - 0.01% (2)
standard binary - 0.01% (2)
all eight - 0.01% (2)
up/down counter - 0.01% (2)
2200 used - 0.01% (2)
stack and - 0.01% (2)
board from - 0.01% (2)
article in - 0.01% (2)
single chip." - 0.01% (2)
use in - 0.01% (2)
that an - 0.01% (2)
back to - 0.01% (2)
arithmetic / - 0.01% (2)
introduced in - 0.01% (2)
consisting of - 0.01% (2)
a board - 0.01% (2)
chips. the - 0.01% (2)
photo below - 0.01% (2)
combined to - 0.01% (2)
instruments introduced - 0.01% (2)
1970, texas - 0.01% (2)
the stack, - 0.01% (2)
2200. the - 0.01% (2)
in march - 0.01% (2)
to replace - 0.01% (2)
photo courtesy - 0.01% (2)
typically use - 0.01% (2)
a stack - 0.01% (2)
to store - 0.01% (2)
in main - 0.01% (2)
stack was - 0.01% (2)
providing a - 0.01% (2)
just 64 - 0.01% (2)
gates. but - 0.01% (2)
keep track - 0.01% (2)
74182 look-ahead - 0.01% (2)
mess o' - 0.01% (2)
large number - 0.01% (2)
is still - 0.01% (2)
carry. for - 0.01% (2)
you're adding - 0.01% (2)
from that - 0.01% (2)
always be - 0.01% (2)
in retro - 0.01% (2)
regardless of - 0.01% (2)
c. this - 0.01% (2)
is called - 0.01% (2)
used today - 0.01% (2)
propagate case - 0.01% (2)
this all - 0.01% (2)
both bits - 0.01% (2)
computed from - 0.01% (2)
the answer - 0.01% (2)
signals by - 0.01% (2)
carry is - 0.01% (2)
set for - 0.01% (2)
bit 1. - 0.01% (2)
or propagated - 0.01% (2)
the powerful - 0.01% (2)
the function - 0.01% (2)
minicomputers to - 0.01% (2)
point is - 0.01% (2)
that each - 0.01% (2)
the carry-in. - 0.01% (2)
xerox alto - 0.01% (2)
an arbitrary - 0.01% (2)
to determine - 0.01% (2)
you do - 0.01% (2)
pdp-11 and - 0.01% (2)
a consequence - 0.01% (2)
possible functions. - 0.01% (2)
and b. - 0.01% (2)
these 16 - 0.01% (2)
selected by - 0.01% (2)
the s0-s3 - 0.01% (2)
plus ab - 0.01% (2)
are simply - 0.01% (2)
added to - 0.01% (2)
actually a - 0.01% (2)
f(a,b) = - 0.01% (2)
the case - 0.01% (2)
carry can - 0.01% (2)
randomly throw - 0.01% (2)
are strange - 0.01% (2)
determine if - 0.01% (2)
a reason - 0.01% (2)
for arithmetic - 0.01% (2)
is there - 0.01% (2)
long addition - 0.01% (2)
from each - 0.01% (2)
column to - 0.01% (2)
the next, - 0.01% (2)
are some - 0.01% (2)
a serial - 0.01% (2)
to avoid - 0.01% (2)
this, the - 0.01% (2)
first and - 0.01% (2)
the delay - 0.01% (2)
the previous - 0.01% (2)
(generate) signals - 0.01% (2)
and big - 0.01% (2)
appears at - 0.01% (2)
opened up - 0.01% (2)
photos, and - 0.01% (2)
circuitry in - 0.01% (2)
image for - 0.01% (2)
that connect - 0.01% (2)
the pads - 0.01% (2)
the external - 0.01% (2)
regions are - 0.01% (2)
chip simplified - 0.01% (2)
underneath the - 0.01% (2)
ttl circuits. - 0.01% (2)
matches the - 0.01% (2)
first to - 0.01% (2)
lookahead logic - 0.01% (2)
addition to - 0.01% (2)
without waiting - 0.01% (2)
for carry - 0.01% (2)
carry lookahead, - 0.01% (2)
projects using - 0.01% (2)
include the - 0.01% (2)
apollo181 cpu, - 0.01% (2)
fourbit cpu, - 0.01% (2)
ttl cpu, - 0.01% (2)
magic-1 (using - 0.01% (2)
the 74f381), - 0.01% (2)
trex, mark - 0.01% (2)
1 forth - 0.01% (2)
outputs in - 0.01% (2)
described above. - 0.01% (2)
values. the - 0.01% (2)
the internal - 0.01% (2)
created when - 0.01% (2)
arbitrary boolean - 0.01% (2)
function f(a, - 0.01% (2)
74181. the - 0.01% (2)
shows p - 0.01% (2)
depends on - 0.01% (2)
ranged from - 0.01% (2)
f(a,b) p - 0.01% (2)
the following - 0.01% (2)
computers using - 0.01% (2)
this circuit - 0.01% (2)
lines select - 0.01% (2)
outputs are - 0.01% (2)
combined with - 0.01% (2)
the design - 0.01% (2)
similarly for - 0.01% (2)
has two - 0.01% (2)
operations, the - 0.01% (2)
select a - 0.01% (2)
is fed - 0.01% (2)
all 16 - 0.01% (2)
compact, so - 0.01% (2)
of them - 0.01% (2)
and made - 0.01% (2)
minicomputer processor - 0.01% (2)
operations. the - 0.01% (2)
is being - 0.01% (2)
are generated - 0.01% (2)
last two - 0.01% (2)
is placed - 0.01% (2)
start with - 0.01% (2)
18 wires - 0.01% (2)
complex carry-lookahead - 0.01% (2)
ancestor of - 0.01% (2)
that you - 0.01% (2)
using right - 0.01% (2)
now.2 i - 0.01% (2)
photos of - 0.01% (2)
circuits from - 0.01% (2)
chip the - 0.01% (2)
8008's tiny - 0.01% (2)
silicon die, - 0.01% (2)
highly magnified. - 0.01% (2)
outside of - 0.01% (2)
the rest - 0.01% (2)
can perform - 0.01% (2)
microprocessor, showing - 0.01% (2)
work together - 0.01% (2)
two values - 0.01% (2)
alu computes - 0.01% (2)
(note that - 0.01% (2)
instruction and - 0.01% (2)
(and other - 0.01% (2)
the arithmetic-logic - 0.01% (2)
and, xor - 0.01% (2)
standard boolean - 0.01% (2)
an output - 0.01% (2)
checks if - 0.01% (2)
first or - 0.01% (2)
unlike most - 0.01% (2)
alu uses - 0.01% (2)
processor is - 0.01% (2)
implement a - 0.01% (2)
new customer - 0.01% (2)
more detail - 0.01% (2)
familiar with - 0.01% (2)
which can - 0.01% (2)
sequence is - 0.01% (2)
nonlinear-feedback shift - 0.01% (2)
history. before - 0.01% (2)
registers and - 0.01% (2)
the tms - 0.01% (2)
program counter. - 0.01% (2)
through a - 0.01% (2)
rom in - 0.01% (2)
a strange - 0.01% (2)
chip, with - 0.01% (2)
labels: 8008, - 0.01% (2)
however, on - 0.01% (2)
die, the - 0.01% (2)
layout more - 0.01% (2)
read from - 0.01% (2)
before being - 0.01% (2)
storage cell - 0.01% (2)
inverts the - 0.01% (2)
key role - 0.01% (2)
the original - 0.01% (2)
8008 instruction - 0.01% (2)
or more - 0.01% (2)
consists of - 0.01% (2)
instruction takes - 0.01% (2)
binary addition - 0.01% (2)
added and - 0.01% (2)
processor for - 0.01% (2)
or xor - 0.01% (2)
8008's alu. - 0.01% (2)
the circuit. - 0.01% (2)
and if - 0.01% (2)
takes two - 0.01% (2)
and b) - 0.01% (2)
(a and - 0.01% (2)
three mode - 0.01% (2)
m2 and - 0.01% (2)
an operation - 0.01% (2)
table, and - 0.01% (2)
alu are - 0.01% (2)
sum and - 0.01% (2)
looks like - 0.01% (2)
is formed - 0.01% (2)
gate. the - 0.01% (2)
by combining - 0.01% (2)
circuitry than - 0.01% (2)
mos logic - 0.01% (2)
and-or-nand gate - 0.01% (2)
circuit above - 0.01% (2)
the structure - 0.01% (2)
c) and - 0.01% (2)
outputs the - 0.01% (2)
alu slice, - 0.01% (2)
inverting the - 0.01% (2)
support the - 0.01% (2)
the m3 - 0.01% (2)
each alu - 0.01% (2)
between doped - 0.01% (2)
there can - 0.01% (2)
is arranged - 0.01% (2)
carry bit. - 0.01% (2)
parallel without - 0.01% (2)
lookahead for - 0.01% (2)
an 8-bit - 0.01% (2)
on two - 0.01% (2)
most 8-bit - 0.01% (2)
the 8008) - 0.01% (2)
one-bit alu - 0.01% (2)
slice takes - 0.01% (2)
bit, and - 0.01% (2)
produces the - 0.01% (2)
has its - 0.01% (2)
eight alu - 0.01% (2)
the triangular - 0.01% (2)
with impurities - 0.01% (2)
at one - 0.01% (2)
the most - 0.01% (2)
the detail - 0.01% (2)
below, you - 0.01% (2)
more importantly - 0.01% (2)
b inputs - 0.01% (2)
bottom. the - 0.01% (2)
metal lines. - 0.01% (2)
vcc (+5 - 0.01% (2)
to vdd - 0.01% (2)
to pull - 0.01% (2)
silicon and - 0.01% (2)
regions of - 0.01% (2)
find a - 0.01% (2)
and asked - 0.01% (2)
are shifted - 0.01% (2)
value and - 0.01% (2)
of three - 0.01% (2)
first cell - 0.01% (2)
are labeled - 0.01% (2)
the wiring - 0.01% (2)
pulled low, - 0.01% (2)
the capacitor. - 0.01% (2)
low, turning - 0.01% (2)
voltage, t2 - 0.01% (2)
is turned - 0.01% (2)
operations (addition, - 0.01% (2)
value is - 0.01% (2)
c will - 0.01% (2)
hand, uses - 0.01% (2)
the 14 - 0.01% (2)
is powered - 0.01% (2)
current position - 0.01% (2)
same as - 0.01% (2)
it only - 0.01% (2)
needs to - 0.01% (2)
count in - 0.01% (2)
understanding the - 0.01% (2)
individual chips. - 0.01% (2)
a silicon - 0.01% (2)
dark lines - 0.01% (2)
indicate the - 0.01% (2)
internal wiring - 0.01% (2)
transistor's gate. - 0.01% (2)
subtraction) and - 0.01% (2)
address in - 0.01% (2)
boards of - 0.01% (2)
added on - 0.01% (2)
right and - 0.01% (2)
alus out - 0.01% (2)
the left. - 0.01% (2)
this process - 0.01% (2)
circuit that - 0.01% (2)
allows a - 0.01% (2)
8008 implements - 0.01% (2)
implementation of - 0.01% (2)
(and, or, - 0.01% (2)
shift register, - 0.01% (2)
with each - 0.01% (2)
count down, - 0.01% (2)
is shifted - 0.01% (2)
for counting - 0.01% (2)
and save - 0.01% (2)
down and - 0.01% (2)
bit for - 0.01% (2)
is it's - 0.01% (2)
gate as - 0.01% (2)
a plain - 0.01% (2)
next bit. - 0.01% (2)
studied digital - 0.01% (2)
circuits to - 0.01% (2)
registers. the - 0.01% (2)
i've examined - 0.01% (2)
intel was - 0.01% (2)
primarily a - 0.01% (2)
wanted to - 0.01% (2)
voltage on - 0.01% (2)
two sides - 0.01% (2)
for datapoint - 0.01% (2)
a time. - 0.01% (2)
references the - 0.01% (2)
era, minicomputers - 0.01% (2)
in contrast - 0.01% (2)
to serial - 0.01% (2)
announced in - 0.01% (2)
memory chips - 0.01% (2)
i3101 chip - 0.01% (2)
64 bits - 0.01% (2)
shift-register memory - 0.01% (2)
storage in - 0.01% (2)
an intel - 0.01% (2)
available at - 0.01% (2)
wasn't a - 0.01% (2)
to take - 0.01% (2)
to wait - 0.01% (2)
half a - 0.01% (2)
i wrote - 0.01% (2)
memory was - 0.01% (2)
the time, - 0.01% (2)
the product - 0.01% (2)
the last - 0.01% (2)
was called - 0.01% (2)
01 was - 0.01% (2)
i3101 ram - 0.01% (2)
the dynamic - 0.01% (2)
in modern - 0.01% (2)
that intel - 0.01% (2)
alu. i - 0.01% (2)
on how - 0.01% (2)
high voltage - 0.01% (2)
stack storage. - 0.01% (2)
metal layer, - 0.01% (2)
photo above, - 0.01% (2)
i removed - 0.01% (2)
layer with - 0.01% (2)
visible. the - 0.01% (2)
lines indicate - 0.01% (2)
and t3 - 0.01% (2)
transistor t2 - 0.01% (2)
processors from - 0.01% (2)
other parts - 0.01% (2)
built their - 0.01% (2)
8-bit data - 0.01% (2)
photo are - 0.01% (2)
bus and - 0.01% (2)
architecture, more - 0.01% (2)
read or - 0.01% (2)
an address - 0.01% (2)
are much - 0.01% (2)
photo. the - 0.01% (2)
written back, - 0.01% (2)
possible to - 0.01% (2)
one unusual - 0.01% (2)
saves a - 0.01% (2)
storage and - 0.01% (2)
since every - 0.01% (2)
you're interested - 0.01% (2)
8008, my - 0.01% (2)
detailed discussion - 0.01% (2)
powered by - 0.01% (2)
the datapoint 2200 - 0.15% (21)
of the 8008 - 0.13% (18)
of the chip - 0.13% (18)
of the 74181 - 0.12% (17)
the 74181 alu - 0.1% (14)
74181 alu chip - 0.1% (14)
the 8008's alu - 0.09% (13)
the metal layer - 0.09% (13)
the data bus - 0.09% (13)
in the 74181 - 0.08% (11)
the 74181 chip - 0.08% (11)
one of the - 0.08% (11)
the diagram below - 0.07% (9)
for each bit - 0.07% (9)
the p and - 0.06% (8)
the die photo - 0.06% (8)
the 8008 microprocessor - 0.06% (8)
part of the - 0.06% (8)
on the right - 0.06% (8)
you can see - 0.06% (8)
on the die - 0.05% (7)
on the other - 0.05% (7)
the sense line - 0.05% (7)
the other hand, - 0.05% (7)
side of the - 0.05% (7)
to build a - 0.05% (7)
of the 8008's - 0.05% (7)
at the top - 0.04% (6)
such as the - 0.04% (6)
using the 74181 - 0.04% (6)
diagram below shows - 0.04% (6)
de bruijn sequence - 0.04% (6)
connected to the - 0.04% (6)
and g signals - 0.04% (6)
the 74181 is - 0.04% (6)
the chip is - 0.04% (6)
there is a - 0.04% (6)
on the chip. - 0.04% (6)
the 8008 is - 0.04% (6)
die photos and - 0.04% (5)
as well as - 0.04% (5)
is based on - 0.04% (5)
each bit of - 0.04% (5)
a plus f(a,b) - 0.04% (5)
note that the - 0.04% (5)
the data bus. - 0.04% (5)
photo of the - 0.04% (5)
the full adder - 0.04% (5)
bit of the - 0.04% (5)
of the die - 0.04% (5)
can see the - 0.04% (5)
►  december (2) - 0.04% (5)
how it works - 0.04% (5)
die photo of - 0.04% (5)
top of the - 0.04% (5)
to generate the - 0.04% (5)
pulls the output - 0.04% (5)
on the left - 0.04% (5)
nonlinear feedback shift - 0.04% (5)
there is no - 0.04% (5)
the 8008 chip - 0.03% (4)
blog posts on - 0.03% (4)
announce my latest - 0.03% (4)
notes and references - 0.03% (4)
controlled by the - 0.03% (4)
of the data - 0.03% (4)
and so forth. - 0.03% (4)
if there is - 0.03% (4)
layer of the - 0.03% (4)
rather than the - 0.03% (4)
post email thisblogthis!share - 0.03% (4)
the tmc 1795 - 0.03% (4)
the chip a - 0.03% (4)
facebookshare to pinterest - 0.03% (4)
follow me at - 0.03% (4)
sense line is - 0.03% (4)
i announce my - 0.03% (4)
latest blog posts - 0.03% (4)
in the first - 0.03% (4)
on twitter, so - 0.03% (4)
to twittershare to - 0.03% (4)
links to this - 0.03% (4)
based on a - 0.03% (4)
this post email - 0.03% (4)
a carry out - 0.03% (4)
a new bit - 0.03% (4)
each bit is - 0.03% (4)
parts of the - 0.03% (4)
below shows how - 0.03% (4)
the output low. - 0.03% (4)
arithmetic and logic - 0.03% (4)
new bit is - 0.03% (4)
shifted to the - 0.03% (4)
shows how the - 0.03% (4)
is pulled low - 0.03% (4)
circuit used in - 0.03% (4)
the top of - 0.03% (4)
of the inverter - 0.03% (4)
74181 alu chip: - 0.03% (4)
but if you - 0.03% (4)
►  april (1) - 0.03% (4)
►  march (1) - 0.03% (4)
►  may (2) - 0.03% (4)
the 8008 has - 0.03% (4)
twitter, so follow - 0.03% (4)
most of the - 0.03% (4)
posts on twitter, - 0.03% (4)
the result is - 0.03% (4)
to facebookshare to - 0.03% (4)
the carry lookahead - 0.03% (4)
comments: links to - 0.03% (4)
me at kenshirriff. - 0.03% (4)
my latest blog - 0.03% (4)
16 logic functions - 0.03% (4)
so follow me - 0.03% (4)
thisblogthis!share to twittershare - 0.03% (4)
of the circuit - 0.03% (4)
is connected to - 0.02% (3)
half of the - 0.02% (3)
the datapoint 2200. - 0.02% (3)
acts as a - 0.02% (3)
the datapoint 2200's - 0.02% (3)
data bus. the - 0.02% (3)
the 8008, the - 0.02% (3)
and the stack - 0.02% (3)
and write the - 0.02% (3)
"8-bit parallel processor - 0.02% (3)
story of the - 0.02% (3)
in electronics on - 0.02% (3)
the 8008 as - 0.02% (3)
8008 uses a - 0.02% (3)
of the photo - 0.02% (3)
few gates by - 0.02% (3)
have an rss - 0.02% (3)
kenshirriff. i also - 0.02% (3)
feed. notes and - 0.02% (3)
set in the - 0.02% (3)
offered on a - 0.02% (3)
gates are implemented - 0.02% (3)
is implemented with - 0.02% (3)
metal layer of - 0.02% (3)
used in the - 0.02% (3)
control line is - 0.02% (3)
an npn transistor - 0.02% (3)
inverter in the - 0.02% (3)
the output high. - 0.02% (3)
schematic of the - 0.02% (3)
transistors in parallel - 0.02% (3)
is at the - 0.02% (3)
74181 alu chip. - 0.02% (3)
share a collector, - 0.02% (3)
in the 74181, - 0.02% (3)
8008 chip was - 0.02% (3)
transistor turns on - 0.02% (3)
the two transistors - 0.02% (3)
see how the - 0.02% (3)
on the die, - 0.02% (3)
to compute the - 0.02% (3)
discussion of the - 0.02% (3)
the circuit used - 0.02% (3)
is similar to - 0.02% (3)
you might wonder - 0.02% (3)
inside the vintage - 0.02% (3)
the vintage 8008 - 0.02% (3)
processor from die - 0.02% (3)
►  february (1) - 0.02% (3)
electronics on march - 0.02% (3)
rss feed. notes - 0.02% (3)
alu chip: how - 0.02% (3)
is built from - 0.02% (3)
on the 8008 - 0.02% (3)
to build an - 0.02% (3)
explain how the - 0.02% (3)
the alu to - 0.02% (3)
carry lookahead circuit - 0.02% (3)
generates the carry - 0.02% (3)
bit is set - 0.02% (3)
and the second - 0.02% (3)
is set in - 0.02% (3)
the second number - 0.02% (3)
on a single - 0.02% (3)
of the alu. - 0.02% (3)
since the 8008 - 0.02% (3)
it is the - 0.02% (3)
also have an - 0.02% (3)
layer is the - 0.02% (3)
removing the metal - 0.02% (3)
make up the - 0.02% (3)
one bit of - 0.02% (3)
how the alu - 0.02% (3)
alu circuit is - 0.02% (3)
almost identical to - 0.02% (3)
the bit pattern - 0.02% (3)
instruction decode circuit - 0.02% (3)
the instruction decoder - 0.02% (3)
logic in the - 0.02% (3)
and information on - 0.02% (3)
at kenshirriff. i - 0.02% (3)
from the datapoint - 0.02% (3)
the vintage 74181 - 0.02% (3)
parallel processor offered - 0.02% (3)
look at the - 0.02% (3)
the image below - 0.02% (3)
74181 chip is - 0.02% (3)
is almost identical - 0.02% (3)
on the schematic - 0.02% (3)
in this article, - 0.02% (3)
the 74181 implements - 0.02% (3)
gates by using - 0.02% (3)
the top and - 0.02% (3)
this article, i - 0.02% (3)
you look at - 0.02% (3)
can be used - 0.02% (3)
the die to - 0.02% (3)
multiple 74181 chips - 0.02% (3)
there are a - 0.02% (3)
each bit position - 0.02% (3)
the logic functions - 0.02% (3)
vintage 8008 processor - 0.02% (3)
can be computed - 0.02% (3)
boolean logic functions - 0.02% (3)
at the bottom. - 0.02% (3)
was used in - 0.02% (3)
a key part - 0.02% (3)
on march 13, - 0.02% (3)
(addition, subtraction) and - 0.01% (2)
arithmetic/logic unit (alu) - 0.01% (2)
74181 alu chip, - 0.01% (2)
circuitry of the - 0.01% (2)
around the edge - 0.01% (2)
performed by the - 0.01% (2)
logical operations (and, - 0.01% (2)
chip is important - 0.01% (2)
of individual chips. - 0.01% (2)
processors from boards - 0.01% (2)
doped silicon regions - 0.01% (2)
the microprocessor era, - 0.01% (2)
minicomputer history. before - 0.01% (2)
that make up - 0.01% (2)
74181 chip simplified - 0.01% (2)
chip. the 74181 - 0.01% (2)
key role in - 0.01% (2)
because of its - 0.01% (2)
minicomputers built their - 0.01% (2)
it was used - 0.01% (2)
the design of - 0.01% (2)
compact, so it - 0.01% (2)
the inverter. the - 0.01% (2)
minicomputer processor and - 0.01% (2)
collector, base and - 0.01% (2)
at the right - 0.01% (2)
to understand how - 0.01% (2)
a switch in - 0.01% (2)
switch in the - 0.01% (2)
made it more - 0.01% (2)
the collector and - 0.01% (2)
a switch between - 0.01% (2)
appears in an - 0.01% (2)
the base to - 0.01% (2)
a minicomputer processor - 0.01% (2)
along with a - 0.01% (2)
transistor appears in - 0.01% (2)
mos transistors in - 0.01% (2)
today in retro - 0.01% (2)
is still used - 0.01% (2)
the popular pdp-11 - 0.01% (2)
74181 ranged from - 0.01% (2)
computers using the - 0.01% (2)
in many minicomputers. - 0.01% (2)
what's inside a - 0.01% (2)
more compact, so - 0.01% (2)
and made it - 0.01% (2)
opened up a - 0.01% (2)
by the alu. - 0.01% (2)
pinterest labels: 8008, - 0.01% (2)
functions such as - 0.01% (2)
three mode lines - 0.01% (2)
74181 is still - 0.01% (2)
for an nmos - 0.01% (2)
gate has transistors - 0.01% (2)
pull the output - 0.01% (2)
used today in - 0.01% (2)
is simply a - 0.01% (2)
the second argument. - 0.01% (2)
eight different arithmetic/logic - 0.01% (2)
uses a different - 0.01% (2)
addition, subtraction, and - 0.01% (2)
through the sum. - 0.01% (2)
sum bit is - 0.01% (2)
behind the 74181's - 0.01% (2)
an article in - 0.01% (2)
and references the - 0.01% (2)
system behind the - 0.01% (2)
you have a - 0.01% (2)
there are 4 - 0.01% (2)
of the 74181, - 0.01% (2)
that there is - 0.01% (2)
how to take - 0.01% (2)
that is, the - 0.01% (2)
more die photos - 0.01% (2)
to select the - 0.01% (2)
and the output - 0.01% (2)
many minicomputers. computers - 0.01% (2)
a nand gate - 0.01% (2)
is described in - 0.01% (2)
with "a plus - 0.01% (2)
ranged from the - 0.01% (2)
m3 control line - 0.01% (2)
has the bit - 0.01% (2)
the datapoint 2200, - 0.01% (2)
the alu operation - 0.01% (2)
decoded on the - 0.01% (2)
bits 3, 4 - 0.01% (2)
the left side - 0.01% (2)
there's a reason - 0.01% (2)
mismatch, the control - 0.01% (2)
of the or - 0.01% (2)
popular pdp-11 and - 0.01% (2)
rest of the - 0.01% (2)
a programmable logic - 0.01% (2)
the control lines - 0.01% (2)
from the alu - 0.01% (2)
in the z80, - 0.01% (2)
and and or - 0.01% (2)
to the powerful - 0.01% (2)
typical full adder - 0.01% (2)
the typical full - 0.01% (2)
not an alu - 0.01% (2)
similarly for the - 0.01% (2)
the right is - 0.01% (2)
full adder circuit. - 0.01% (2)
to match the - 0.01% (2)
cpu, 4 bit - 0.01% (2)
carry lookahead for - 0.01% (2)
as much current - 0.01% (2)
important because of - 0.01% (2)
its key role - 0.01% (2)
in minicomputer history. - 0.01% (2)
look-ahead carry generator - 0.01% (2)
mess o' wires. ↩ - 0.01% (2)
forth and big - 0.01% (2)
trex, mark 1 - 0.01% (2)
(using the 74f381), - 0.01% (2)
ttl cpu, magic-1 - 0.01% (2)
apollo181 cpu, fourbit - 0.01% (2)
by one diode - 0.01% (2)
74181 include the - 0.01% (2)
projects using the - 0.01% (2)
au (arithmetic unit) - 0.01% (2)
before the microprocessor - 0.01% (2)
history of the - 0.01% (2)
era, minicomputers built - 0.01% (2)
of the 16 - 0.01% (2)
arithmetic functions are - 0.01% (2)
the 74181's 16 - 0.01% (2)
strange, but there - 0.01% (2)
of the 74181's - 0.01% (2)
voltage to turn - 0.01% (2)
schematic is based - 0.01% (2)
photos of the - 0.01% (2)
►  may (1) - 0.01% (2)
►  november (5) - 0.01% (2)
►  february (2) - 0.01% (2)
►  october (1) - 0.01% (2)
►  december (1) - 0.01% (2)
►  march (2) - 0.01% (2)
it works and - 0.01% (2)
►  august (1) - 0.01% (2)
►  october (3) - 0.01% (2)
►  january (3) - 0.01% (2)
why it's so - 0.01% (2)
alu (arithmetic/logic unit) - 0.01% (2)
►  july (3) - 0.01% (2)
on a diagram - 0.01% (2)
►  january (1) - 0.01% (2)
dozen usb chargers - 0.01% (2)
a dozen usb - 0.01% (2)
photos: its unusual - 0.01% (2)
bizarre functions such - 0.01% (2)
and why it's - 0.01% (2)
as "a plus - 0.01% (2)
74181's set of - 0.01% (2)
an xor gate - 0.01% (2)
to simplify routing - 0.01% (2)
wikimedia, cc by-sa - 0.01% (2)
by poil on - 0.01% (2)
the chip. these - 0.01% (2)
the chip works. - 0.01% (2)
design of a - 0.01% (2)
base current will - 0.01% (2)
on the die. - 0.01% (2)
introduced the 74181 - 0.01% (2)
arithmetic / logic - 0.01% (2)
unit (alu) chip, - 0.01% (2)
which put a - 0.01% (2)
full 4-bit alu - 0.01% (2)
are highlighted in - 0.01% (2)
the multiple-emitter transistors - 0.01% (2)
are high, the - 0.01% (2)
on one fast - 0.01% (2)
is implemented by - 0.01% (2)
with multiple emitters - 0.01% (2)
but in march - 0.01% (2)
more complex than - 0.01% (2)
nor gate as - 0.01% (2)
are a few - 0.01% (2)
types of gates - 0.01% (2)
for the carry - 0.01% (2)
chip provided 32 - 0.01% (2)
a detailed discussion - 0.01% (2)
functions, as well - 0.01% (2)
turn on q4 - 0.01% (2)
if q2 turns - 0.01% (2)
chip simplified the - 0.01% (2)
used in an - 0.01% (2)
1970, texas instruments - 0.01% (2)
the and-or-invert gate - 0.01% (2)
the silicon layer - 0.01% (2)
to the right. - 0.01% (2)
removed the metal - 0.01% (2)
74181 chip with - 0.01% (2)
their processors from - 0.01% (2)
below, you can - 0.01% (2)
alu chip in - 0.01% (2)
in a ceramic - 0.01% (2)
boards of individual - 0.01% (2)
pulling the output - 0.01% (2)
low, r1's current - 0.01% (2)
the gates are - 0.01% (2)
operations (addition, subtraction) - 0.01% (2)
is equivalent to - 0.01% (2)
of simple gates. - 0.01% (2)
two transistors share - 0.01% (2)
and logical operations - 0.01% (2)
early minicomputers built - 0.01% (2)
input is low - 0.01% (2)
if the first - 0.01% (2)
alus out of - 0.01% (2)
due to the - 0.01% (2)
a large number - 0.01% (2)
the second is - 0.01% (2)
is high and - 0.01% (2)
the first input - 0.01% (2)
in an unusual - 0.01% (2)
of the architecture, - 0.01% (2)
instruction set and - 0.01% (2)
previous article has - 0.01% (2)
the polysilicon gate - 0.01% (2)
the schematic is - 0.01% (2)
diagram by poil - 0.01% (2)
on wikimedia, cc - 0.01% (2)
address in the - 0.01% (2)
by-sa 3.0, with - 0.01% (2)
the metal wiring - 0.01% (2)
to make the - 0.01% (2)
with hydrochloric acid - 0.01% (2)
compared to the - 0.01% (2)
voltage on the - 0.01% (2)
the two sides - 0.01% (2)
a transistor is - 0.01% (2)
the photo are - 0.01% (2)
logic, where a - 0.01% (2)
with active-low logic - 0.01% (2)
is the same - 0.01% (2)
is used as - 0.01% (2)
pinterest labels: electronics, - 0.01% (2)
the circuit is - 0.01% (2)
hand, uses a - 0.01% (2)
value is stored - 0.01% (2)
voltage, t2 is - 0.01% (2)
from die photos: - 0.01% (2)
its unusual counters - 0.01% (2)
t2 is turned - 0.01% (2)
shows the circuitry - 0.01% (2)
in terms of - 0.01% (2)
low, turning on - 0.01% (2)
article has a - 0.01% (2)
fourbit cpu, 4 - 0.01% (2)
bit ttl cpu, - 0.01% (2)
magic-1 (using the - 0.01% (2)
74f381), trex, mark - 0.01% (2)
1 forth and - 0.01% (2)
big mess o' - 0.01% (2)
the 8008's alu. - 0.01% (2)
information on how - 0.01% (2)
74182 look-ahead carry - 0.01% (2)
the architecture, more - 0.01% (2)
detailed discussion of - 0.01% (2)
8008, my previous - 0.01% (2)
the stack storage. - 0.01% (2)
interested in the - 0.01% (2)
used for the - 0.01% (2)
in a pseudo-random - 0.01% (2)
no way to - 0.01% (2)
on the 74181 - 0.01% (2)
one unusual feature - 0.01% (2)
this is the - 0.01% (2)
the die photo. - 0.01% (2)
appear in the - 0.01% (2)
the appropriate read - 0.01% (2)
data bus and - 0.01% (2)
that connect the - 0.01% (2)
is pulled low, - 0.01% (2)
stored on the - 0.01% (2)
the 74181 include - 0.01% (2)
to hold the - 0.01% (2)
keep track of - 0.01% (2)
to implement the - 0.01% (2)
the 8008's stack - 0.01% (2)
18 wires connecting - 0.01% (2)
completed the 8008 - 0.01% (2)
processor board onto - 0.01% (2)
could build a - 0.01% (2)
the chip's external - 0.01% (2)
the stack. the - 0.01% (2)
from about 3500 - 0.01% (2)
tiny transistors (yellow) - 0.01% (2)
connected by a - 0.01% (2)
the outside of - 0.01% (2)
to keep track - 0.01% (2)
metal wiring layer - 0.01% (2)
the photo above, - 0.01% (2)
of the intel - 0.01% (2)
in main memory - 0.01% (2)
datapoint 2200 used - 0.01% (2)
photo courtesy of - 0.01% (2)
8008 microprocessor, showing - 0.01% (2)
the stack and - 0.01% (2)
for the 8008 - 0.01% (2)
article in electronics - 0.01% (2)
photo below shows - 0.01% (2)
the die, you - 0.01% (2)
result is the - 0.01% (2)
the first cell - 0.01% (2)
added on the - 0.01% (2)
read and write - 0.01% (2)
is used to - 0.01% (2)
each row is - 0.01% (2)
unusual feature of - 0.01% (2)
at the time, - 0.01% (2)
8008 is a - 0.01% (2)
if you've studied - 0.01% (2)
as a plain - 0.01% (2)
bit for counting - 0.01% (2)
the logic gate - 0.01% (2)
to count down, - 0.01% (2)
left and a - 0.01% (2)
in the same - 0.01% (2)
photos and explain - 0.01% (2)
a shift register, - 0.01% (2)
the 8008 implements - 0.01% (2)
shows the 8008's - 0.01% (2)
right and a - 0.01% (2)
tiny silicon die, - 0.01% (2)
two bits are - 0.01% (2)
is placed on - 0.01% (2)
highly magnified. around - 0.01% (2)
the left and - 0.01% (2)
are shifted to - 0.01% (2)
bruijn sequence is - 0.01% (2)
the apollo181 cpu, - 0.01% (2)
retro projects using - 0.01% (2)
the 8008, my - 0.01% (2)
is called the - 0.01% (2)
mode lines to - 0.01% (2)
the logic operations, - 0.01% (2)
inputs to the - 0.01% (2)
a carry. for - 0.01% (2)
of the four - 0.01% (2)
alu slice takes - 0.01% (2)
if you're adding - 0.01% (2)
this is called - 0.01% (2)
the die photos - 0.01% (2)
will be a - 0.01% (2)
switch between the - 0.01% (2)
gate in the - 0.01% (2)
the m3 control - 0.01% (2)
and b inputs - 0.01% (2)
in on the - 0.01% (2)
putting this all - 0.01% (2)
both bits are - 0.01% (2)
the polysilicon layer - 0.01% (2)
p (propagate) signal - 0.01% (2)
be computed from - 0.01% (2)
the circuitry is - 0.01% (2)
at one of - 0.01% (2)
eight alu slices - 0.01% (2)
bit. in most - 0.01% (2)
takes two input - 0.01% (2)
generates the carry-out - 0.01% (2)
the answer is - 0.01% (2)
carry. for instance, - 0.01% (2)
where a is - 0.01% (2)
you're interested in - 0.01% (2)
a complex carry-lookahead - 0.01% (2)
the idea of - 0.01% (2)
a new customer - 0.01% (2)
and instruction set. - 0.01% (2)
probably using right - 0.01% (2)
ancestor of the - 0.01% (2)
f(a,b) = not - 0.01% (2)
shifting is performed - 0.01% (2)
of a plus - 0.01% (2)
alu to perform - 0.01% (2)
matches a bit - 0.01% (2)
start with a - 0.01% (2)
vertically through the - 0.01% (2)
the 8008's instruction - 0.01% (2)
a reason for - 0.01% (2)
and the instruction - 0.01% (2)
to and with - 0.01% (2)
is to use - 0.01% (2)
instruction decoder generates - 0.01% (2)
instruction set is - 0.01% (2)
other hand, uses - 0.01% (2)
the carry out - 0.01% (2)
to the next, - 0.01% (2)
four bits in - 0.01% (2)
one-bit alu slice - 0.01% (2)
the carry to - 0.01% (2)
parallel without waiting - 0.01% (2)
saves a few - 0.01% (2)
complex carry-lookahead circuit - 0.01% (2)
signals for each - 0.01% (2)
the same as - 0.01% (2)
the output bit - 0.01% (2)
is the carry-in - 0.01% (2)
as described above. - 0.01% (2)
the layout more - 0.01% (2)
with the carry-in - 0.01% (2)
the chip, with - 0.01% (2)
the stack counter - 0.01% (2)
way to implement - 0.01% (2)
a nonlinear feedback - 0.01% (2)
using right now.2 - 0.01% (2)
to the external - 0.01% (2)
customer for the - 0.01% (2)
find a new - 0.01% (2)
the metal layer, - 0.01% (2)
a processor for - 0.01% (2)
the transistors and - 0.01% (2)
chip was a - 0.01% (2)
was called the - 0.01% (2)
the last two - 0.01% (2)
16 boolean logic - 0.01% (2)
inside the chip, - 0.01% (2)
of storage in - 0.01% (2)
is the ancestor - 0.01% (2)
of the 8008, - 0.01% (2)
without waiting for - 0.01% (2)
(and other parts - 0.01% (2)
a carry bit. - 0.01% (2)
there will be - 0.01% (2)
carry out from - 0.01% (2)
first or the - 0.01% (2)
generated from bit - 0.01% (2)
the first or - 0.01% (2)
arbitrary boolean function - 0.01% (2)
the previous section - 0.01% (2)
p (propagate) and - 0.01% (2)
g (generate) signals - 0.01% (2)
the arithmetic-logic unit - 0.01% (2)
and g are - 0.01% (2)
article, i reverse-engineer - 0.01% (2)
an arbitrary boolean - 0.01% (2)
depends on the - 0.01% (2)
(note that the - 0.01% (2)
the 8-bit data - 0.01% (2)
the 8008 microprocessor, - 0.01% (2)
wiring layer (white). - 0.01% (2)
by a metal - 0.01% (2)
transistors (yellow) connected - 0.01% (2)
about 3500 tiny - 0.01% (2)
value of f. - 0.01% (2)
the value of - 0.01% (2)
resulting in the - 0.01% (2)
►  june (1) - 0.01% (2)

Here you can find chart of all your popular one, two and three word phrases. Google and others search engines means your page is about words you use frequently.

Copyright © 2015-2016 hupso.pl. All rights reserved. FB | +G | Twitter

Hupso.pl jest serwisem internetowym, w którym jednym kliknieciem możesz szybko i łatwo sprawdź stronę www pod kątem SEO. Oferujemy darmowe pozycjonowanie stron internetowych oraz wycena domen i stron internetowych. Prowadzimy ranking polskich stron internetowych oraz ranking stron alexa.