In Lab 6, you will implement a pipelined version of the LC-3b. The pipeline for the LC-3b has five stages: Fetch
(F), Decode/Register Read (DE), Address Generation/Execute (AGEX), Data Memory Access (MEM), and Store Result
(SR). Between each stage, there are pipeline latches that are used to propagate data through the pipeline every cycle (see
Figure 1). The main logic components of each stage are shown in Figures 2-6. You will need to implement each stage as
shown in these figures. Some logic blocks in the figures are labeled LOGIC. The outputs of these blocks are shown in
the figure, but the inputs to some of these blocks are omitted. It is your job to figure out the inputs to these blocks and the
implementation of the logic inside the blocks. All of these blocks, including the Dependency Check Logic, generate
outputs that control the stalling of the pipeline and the insertion of pipeline bubbles.
The remainder of this section describes the pipelined LC-3b microarchitecture.
The LC-3b pipeline has five stages. The F stage is used for fetching an instruction into the DE latches. In the DE stage, the
control store is accessed to generate some of the control signals required for processing the instruction. In parallel with the
control store access, the register file is also accessed to retrieve the register operands of the instruction. The Dependency
Check Logic determines if the instruction in the DE stage is reading a value produced by an older instruction that is in the
AGEX, MEM, or SR stage. If so, the instruction in the DE stage should not be propagated to the next stage (this will be
described in more detail later). The AGEX stage performs address computation for instructions that need to generate an
address. Operate instructions also produce their result in this stage using the ALU or the shifter. In the MEM stage, load
instructions read data from memory, and store instructions write data to memory. Control instructions have to wait until
the MEM stage to update the PC since TRAP instructions need to obtain the starting address of the TRAP sevice routine
from memory. The direction of a conditional branch instruction is also determined in the MEM stage. Instructions that
write into a destination register and set the condition codes perform these updates in the SR stage. All other instructions
do nothing in the SR stage.
An instruction in the DE stage may require a value produced by an older instruction that is in the AGEX, MEM, or SR
stage. If so, the instruction in the DE stage should be stalled, and a bubble should be inserted into the pipeline. Note
that this implementation implies that we are NOT using data forwarding. The dependency check is performed by the
Dependency Check Logic in the DE stage. The inputs to this logic are shown in Figure 3. The logic has one output
signal, DEP.STALL, which is asserted if a dependency exists.
To determine if a dependency exists, the Dependency Check Logic compares the destination register number of the
instructions in the AGEX, MEM, and SR stages to the source register numbers of the instruction in the DE stage. If a
match is found and the instruction in the DE stage actually needs the source register (as indicated by the SR1.NEEDED
or SR2.NEEDED control signal) and an instruction in a later stage actually writes to the same register (as indicated by
the V.AGEX.LD.REG, V.MEM.LD.REG, or V.SR.LD.REG signals), DEP.STALL should be set to 1. The Dependency
Check Logic also checks for dependencies on the condition codes. If the instruction in the DE stage is a conditional
branch instruction (as indicated by the BR.OP control signal), and if any of the instructions in the AGEX, MEM, or SR
stages is writing to the condition codes, DEP.STALL should be set to 1.
The basic pipelined microarchitecture of the LC-3b stalls the pipeline after a control instruction is fetched. These in-
structions are resolved in the MEM stage. Hence, a three-cycle bubble is inserted into the pipeline after each control
instruction. A control instruction is identified using the BR.STALL signal from the microcontrol store. This signal is 1
for all control instructions and 0 for all other instructions. If any of the instructions in the DE, AGEX, or MEM stages is
1
a valid control instruction, then the F stage should insert bubbles into the pipeline. This is accomplished by setting the
valid bit of the DE latches (DE.V) to 0.
There are two caches in the pipelined LC-3b microarchitecture: the Instruction Cache (I-Cache) and the Data Cache
(D-Cache). The I-Cache is accessed in the F stage. If the data is found in the I-Cache, the I-Cache asserts the ICACHE.R
signal. The D-Cache is accessed in the MEM stage by those instructions that need to read data from or write data to
memory. These instructions should have the DCACHE.EN control signal set in the control store. When the D-Cache
access is complete, the D-Cache asserts the DCACHE.R signal.
In this stage, the I-Cache is accessed using the address in the PC. The I-Cache asserts the ICACHE.R signal when the
access is complete. This signal is asserted some time in the middle of the clock cycle. If the I-Cache is not ready, then
logic in the F stage needs to stall the pipeline. Remember that the valid bits associated with the pipeline latches are used
to accomplish this. If the data fetched from the I-Cache is garbage (i.e. ICACHE.R is not asserted) and the pipeline is
not stalling for some other reason, then the valid bit for the DE stage latches (DE.V) should be set to 0. This valid bit
indicates that the values in the DE latches are not meaningful and can be ignored.
In the simulator, you are given an icache access function. This function takes as input a 16-bit address, which should
come from the PC. The outputs provided by this function are the 1-bit ICACHE.R signal and the 16-bit instruction. You
must use this interface to perform accesses to the I-Cache.
The F stage also includes the logic used to update the PC. If there are no stalls or control instructions in the pipeline,
the PC should be incremented by 2. If a control instruction other than TRAP is supposed to write into the PC, the
TARGET.PC value coming from the MEM stage should be latched into the PC at the end of the current cycle. If a TRAP
instruction is supposed to write into the PC, the TRAP.PC value coming from the MEM stage should be latched into the
PC at the end of the current cycle. The next value to be latched into the PC is controlled by the MEM.PCMUX signal,
which is generated in the MEM stage, and the LD.PC signal, which is generated by a logic block you should design.
At the end of the clock cycle, if the LD.DE signal is asserted, the DE latches (which contain DE.NPC, DE.IR, and DE.V)
should latch their input values. DE.NPC contains the address of the next instruction, and DE.IR contains the current
instruction fetched from the I-Cache. It is your job to figure out the logic that generates the LD.DE signal. Think about
when you do not want to load enable the DE latches. Hint: Do you want to load enable the DE latches if DEP.STALL is
asserted? How about MEM.STALL?
The instruction in the DE stage accesses the control store using a 6-bit address that is obtained by concatenating IR[15:11]
and IR[5]. Note that IR[11] and IR[5] are not actually part of the opcode, but they are used to access the control store.
These bits are meaningful for some instructions (think about which instructions), and based on the value of these bits,
different values are assigned to the control signals in different entries of the control store.
Each entry in the control store contains 23 bits that are used to control different structures in various stages of the pipeline.
Table 2 shows the pipeline stages in which each bit in the control store is used. At the end of the clock cycle, 20 bits from
the control store are latched into the AGEX.CS latch.
The instruction in the DE stage also reads the register file and the condition codes. The register file has two read ports: one
for SR1 and one for SR2. DE.IR[8:6] are used to address the register file to read SR1. Either DE.IR[11:9] or DE.IR[2:0]
are used to address the register file to read SR2. DE.IR[13] is used to select between DE.IR[11:9] or DE.IR[2:0].
2
At the end of the clock cycle, the SR1 value from the register file is latched into the AGEX.SR1 latch, and the SR2
value is latched into the AGEX.SR2 latch. The value of the condition codes is latched into the 3-bit AGEX.CC latch.
Condition code N is stored in AGEX.CC[2], Z is stored in AGEX.CC[1], and P is stored in AGEX.CC[0]. Note that the
condition codes and register file are read and the values obtained are latched regardless of whether an instruction needs
these values.
The register number (ID) for the destination register is latched into the AGEX.DRID latch at the end of the clock cycle.
The DRMUX signal from the control store selects whether DE.IR[11:9] or the value 7 is latched into AGEX.DRID.
The DE stage also contains the Dependency Check Logic, whose operation was described earlier. The output of this logic
(DEP.STALL) indicates whether or not the instruction in the DE stage should be propagated forward. If DEP.STALL is
asserted, the state of the DE latches should not be changed, and a bubble needs to be inserted into the AGEX stage. This
is accomplished by setting the valid bit for the AGEX stage (AGEX.V) to 0. Other actions need to be taken to preserve
the correct value of the PC. Therefore, the DEP.STALL signal is also used by the structures physically located in the F
stage. It is your job to figure out how the DEP.STALL signal affects the logic in the F stage.
The BR.STALL signal from the control store indicates that the instruction being processed is a control instruction, and
hence the frontend of the pipeline should be stalled until this instruction updates the PC in the MEM stage. In the
DE stage, if DE.V is 1 and BR.STALL is 1, then the DE.BR.STALL signal should be asserted. This indicates that the
instruction in the DE stage is a valid control instruction. The DE.BR.STALL signal is used to insert bubbles into the
pipeline in the F stage. It is again your job to figure out how to use the DE.BR.STALL signal. Think about all cases that
might happen. For example, what happens if a branch instruction in the DE stage is stalled due to a data dependency on
an older instruction that sets the condition codes? Should the F stage still insert a bubble into the pipeline?
Note that you also need to design the logic required to generate the LD.AGEX signal and the input signal to the AGEX.V
latch. Think about when you need to load disable the AGEX latches and when you need to insert a bubble into the AGEX
stage.
During the AGEX stage, operate instructions compute their result. Instructions that need to generate an address (to update
the PC or to access memory) also calculate their address in this stage. The control signals from the AGEX.CS latches
control the muxes in this stage.
Note that there are two logic structures you need to design in this stage. One logic structure determines the LD.MEM
signal and the input signal to the MEM.V latch. The other logic structure generates the signals to be sent to the previous
stages of the pipeline. The outputs of this structure are V.AGEX.LD.CC, V.AGEX.LD.REG, and V.AGEX.BR.STALL.
The first two signals are required by the Dependency Check Logic. V.AGEX.BR.STALL indicates that the instruction
being processed in the AGEX stage is a valid control instruction, and therefore, the frontend of the pipeline needs to stall
and insert bubbles. Note that this logic block simply gates the LD.CC, LD.REG, and BR.STALL control signals from
the AGEX.CS latch with the AGEX.V bit.
In this stage, the D-Cache is accessed by those instructions that need to read from or write to memory (as indicated by
the DCACHE.EN bit in the control store). The DCACHE.R/W bit in the control store indicates a read or write access,
and the DATA.SIZE signal from the control store indicates whether this is a byte or word access.
The inputs to the D-Cache are:
1. 1-bit enable signal (the DCACHE.EN signal from the MEM.CS latch gated with MEM.V)
2. 2-bit WE signal. WE0 is the write-enable for the the low byte of a word. WE1 is the write-enable for the high
byte of a word. You will need to generate these signals based on the values of DCACHE.R/W, DATA.SIZE, and
MEM.ADDRESS[0].
3
3. 16-bit input address, MEM.ADDRESS[15:0], indicating which word is to be accessed.
4. 16-bit input data. This is the data that needs to be written into the D-Cache if DCACHE.R/W is 1.
1. 1-bit DCACHE.R signal. If this signal is asserted it means that the access is complete.
2. 16-bit output data. This is the data read from the D-Cache. Note that you need to design the logic to shift and sign
extend the appropriate byte if the access is a byte access.
In the simulator, you are given a dcache access function, which you need to call if the 1-bit enable signal to the D-Cache
is set. This function takes as input the two WE signals, the 16-bit address, and the 16-bit input data. This function
outputs the DCACHE.R bit and the 16-bit output data. You must use this interface when accessing the D-Cache. For
further explanation, see the shell code.
One signal you need to generate in this stage is the MEM.STALL signal. This signal is used to stall the pipeline and
insert a bubble into the SR latches if a valid memory access is not complete (i.e. DCACHE.R is 0). This signal is also
required by all previous stages to correctly stall the pipeline.
Control instructions update the PC when they reach the MEM stage. The BR LOGIC block shown in Figure 5 generates
the 2-bit PCMUX signal required by the F stage of the pipeline. You must implement this logic. There are six inputs to
this logic:
1. 1-bit valid bit from the MEM.V latch. This bit is set if the instruction in the MEM stage is valid.
2. 1-bit BR.OP signal from the MEM.CS latch. This bit is set if the instruction is a branch.
3. 1-bit UNCON.OP signal from the MEM.CS latch. This bit is set if the instruction is a JSR/JSRR or a JMP.
4. 1-bit TRAP.OP signal from the MEM.CS latch. This bit is set if the instruction is a TRAP.
5. Values of the condition codes from the MEM.CC latch.
6. MEM.IR[11:9]: bits [11:9] of the instruction in the MEM stage.
Another logic block that you need to implement is the block that generates the input to the SR.V latch. The last block you
need to implement in this stage is the one whose outputs are V.MEM.LD.CC, V.MEM.LD.REG, and V.MEM.BR.STALL.
The V.MEM.LD.CC and V.MEM.LD.REG signals are inputs to the Dependency Check Logic. The V.MEM.BR.STALL
signal is needed in the F stage to insert a bubble into the pipeline. Note that although control instructions are resolved in
the MEM stage, we still need to insert a bubble while a control instruction is being processed in the MEM stage. Think
about why it should be this way. Also think about how the LD.PC signal should be generated if a control instruction is
being processed in the MEM stage.
This stage is the stage where the instruction, if it is valid (as indicated by SR.V), writes into the register file and sets the
condition codes. A 4-input mux, whose control signals come from the SR.CS latch, selects the 16-bit data to be written
into the register file. This data can come from one of four places:
1. SR.ADDRESS latch, which contains the address that was generated in the AGEX stage and propagated through
the pipeline.
2. SR.DATA latch, which contains the data read from memory (and shifted and sign-extended, if it was a byte access)
in the MEM stage and stored in SR.DATA at the end of the previous clock cycle.
4
3. SR.NPC latch, which contains the address of the next instruction. Think about why this would possibly be written
into the destination register.
4. SR.ALU.RESULT latch, which contains the result generated by the shifter or the ALU in the AGEX stage and
propagated through the pipeline.
For each instruction that writes to a destination register, you must determine which of the four values above should be
loaded into the destination register. You should set the value of the 2-bit DR.VALUEMUX signal in the control store
accordingly.
The SR stage also contains the logic that determines the values of the condition codes. The last logic block contained in
this stage outputs the V.SR.LD.REG and V.SR.LD.CC signals indicating that a valid instruction is writing into the register
file and condition codes, respectively. These signals are used as write-enable signals in the register file and condition
codes; they are also inputs to the Dependency Check Logic.
Note that the latches for the SR stage do not have a load-enable signal (LD.SR) associated with them. Why is a load-
enable signal not required for the SR latches?
The structures in this stage are implemented in the simulator for you to help get you started.
The control signals used in each stage are listed in Table 1. Note that some of these control signals come from the control
store (see Table 2). There are 23 signals stored in each entry of the control store. Three of these signals are only needed
in the DE stage. Therefore, only 20 of the control store signals need to be propagated to the next stage (AGEX). These
signals are latched into the AGEX.CS latch shown on the datapath. Nine of the 20 signals are only needed in the AGEX
stage, so only 11 signals are propagated into the next stage (MEM). As shown in Table 2, 7 of the control signals from
the MEM.CS latch are not needed beyond the MEM stage, so only 4 signals are latched into the SR.CS latch. In the
simulator, you are given the code that propagates the necessary control signals from one stage to the next.
As mentioned in the previous sections, you will need to implement the logic to generate the following stall signals. These
signals are also shown in Table 3.
1. ICACHE.R: Asserted if the I-Cache provides a useful instruction in this cycle. If 0, the F stage should insert
bubbles into the pipeline.
2. DEP.STALL: Asserted if the instruction in the DE stage is valid and at least one of its input values has not been
written into the register file yet.
3. MEM.STALL: Asserted if the instruction in the MEM stage is valid and needs to access memory, and the DCACHE.R
signal is 0.
4. V.DE.BR.STALL: Asserted if the instruction in the DE stage is a valid control instruction.
5. V.AGEX.BR.STALL: Asserted if the instruction in the AGEX stage is a valid control instruction.
6. V.MEM.BR.STALL: Asserted if the instruction in the MEM stage is a valid control instruction.
These signals are already declared and initialized in the simulator shell code for you. You will need to generate their
values and use them to implement some of the logic blocks in the pipeline.
5
1.3 What You Need to Do
In Lab 6, you need to complete the simulator to implement the pipeline described in this document. To do this, you need
to figure out what the unimplemented logic blocks are supposed to do. You also need to fill out the new microcontrol
store at the end of this document.
You are NOT required to implement the RTI instruction or interrupt/exception handling.
6
FETCH DECODE AGEX MEM SR
+2
Address
Register Generation
Logic
File DCache
PC Destination Reg.
Value
Select Logic
Control Store
ALU
ROM
ICACHE SHF
Branch
CS
Logic
Dependency
CS
Check Logic
CS
V V V V
16 16 16 DE.NPC
MEM.PCMUX
2 1 0
2 +2
LD.DE
16
16
INPUTS LD.PC
LOGIC
PC
16
ICACHE 16 DE.IR
DE.V
INPUTS LOGIC
ICACHE.R
LD.DE
DE.NPC
16
AGEX.NPC
DE.V LOGIC
[15] [22:3]
CONTROL 23 20 AGEX.CS
5
STORE [2:0],[12],[15]
(2^6 x 23)
SR.REG.DATA
V.SR.LD.REG
SR.DRID
6
DE.IR
AGEX.IR
3 16
DE.IR[15:11]@DE.IR[5] 16
CONTROL.STORE.ADDRESS
AGEX.SR1
SR1 16
DE.IR
DE.IR[8:6] 3
REG
DE.IR[11:9] FILE
3 SR2
0 16
DE.IR[2:0]
AGEX.SR2
SR2.IDMUX
V.SR.LD.CC
DE.V CC AGEX.CC
3 3
3
SR1.NEEDED DE.IR[11:9] 0 AGEX.DRID
SR.CC.DATA
SR2.NEEDED 3
111 1 AGEX.V
DEPENDENCY
V.AGEX.LD.CC
DE.BR.OP
DEP.STALL CHECK LOGIC V.MEM.LD.CC
DRMUX LD.AGEX
V.SR.LD.CC
3 3 3
LOGIC
AGEX.DRID
V.MEM.LD.REG
INPUTS
MEM.DRID
V.AGEX.LD.REG
V.SR.LD.REG
SR.DRID
0
AGEX. NPC 16
16
1 1
16
LSHF1 LSHF1 16 16
MEM. ADDRESS
0
ADDR1MUX
16 16
ADDR2MUX 0 1 2 3 ADDRESSMUX
2
AGEX. CS
ZEXT&LSHF1
16
16 16 16 16 MEM. CS
AGEX.CS[19:9]
11
AGEX.IR[5:0]
ZERO
SEXT
SEXT
SEXT
AGEX.NPC MEM. NPC
16
[10:0]
[5:0]
[8:0]
[7:0]
MEM. CC
AGEX. IR AGEX.CC
3
16 16
16
A
16
0 1
AGEX. SR2 16 B 16
SEXT 16 ALU
IR[4:0] 1
AGEX.CS[BR.STALL]
16 ALU.RESULTMUX MEM. IR
AGEX.CS[LD.REG]
AGEX.CS[LD.CC]
AGEX.IR
AGEX. CC 16
SR2MUX MEM. DRID
AGEX.DRID
2 3
AGEX.V ALUK
LD.MEM
INPUTS LOGIC
LOGIC
V.AGEX.LD.CC
V.AGEX.LD.REG
AGEX.DRID V.AGEX.BR.STALL
3
MEM.ADDRESS[0]
16
DATA.SIZE
SR.ADDRESS
16
MEM.ADDRESS DATA.SIZE WE
DCACHE.R/W LOGIC
16 SR.DATA
16
MEM.CS
DCACHE.R WE1 WE0
ADDR
SR.CS
V.DCACHE.EN DCACHE 16
LOGIC
DCACHE.EN
MEM.NPC MEM.V EN
DATA
MEM.CS[10:7]
MEM.CC 4
16
DATA.SIZE
LOGIC SR.NPC
16
MEM.ALU.RESULT MEM.ADDRESS[0] MEM.NPC 16
MEM.CS[BR.STALL]
MEM.CS[LD.REG]
MEM.CS[LD.CC]
MEM.CC MEM.ALU.RESULT
16
MEM.V
SR.ALU.RESULT
3
MEM.IR IR[11:9]
MEM.V
BR.OP
MEM.IR SR.IR
UNCON.OP BR 16
MEM.DRID
SR.DRID
3
MEM.V
SR.V
3 V.MEM.LD.CC
V.MEM.LD.REG LOGIC INPUTS LOGIC
MEM.DRID
V.MEM.BR.STALL
MEM.PCMUX
V.SR.LD.CC
SR STAGE
SR.ADDRESS
SR.REG.DATA
SR.CC.DATA
LOGIC
SR.DATA
SR.V 3
SR.CS[3:2]
CC
SR.CS
16 LOGIC
0 16 16
1
SR.NPC
16
16 2
16
SR.ALU.RESULT
DR.VALUEMUX
SR.IR
SR.DRID
SR.V
SR.DRID
Fig.6 Store Result Stage (SRStage)
Stage Signal Name Signal Values
FETCH MEM.PCMUX/2: PC+2 ;select pc+2
TARGET.PC ;select MEM.TARGET.PC (branch target)
TRAP.PC ;select MEM.TRAP.PC
LD.PC/1: NO(0), LOAD(1)
LD.DE/1: NO(0), LOAD(1)
DECODE DRMUX/1: 11.9 ;destination IR[11:9]
R7 ;destination R7
SR1.NEEDED/1: NO(0), YES(1) ;asserted if instruction needs SR1
SR2.NEEDED/1: NO(0), YES(1) ;asserted if instruction needs SR2
DE.BR.OP/1: NO(0), BR(1) ;BR Opcode
SR2.IDMUX/1: 2.0 ;source IR[2:0]
11.9 ;source IR[11:9]
LD.AGEX/1: NO(0), LOAD(1)
V.AGEX.LD.CC/1: NO(0), LOAD(1)
V.MEM.LD.CC/1: NO(0), LOAD(1)
V.SR.LD.CC/1: NO(0), LOAD(1)
V.AGEX.LD.REG/1: NO(0), LOAD(1)
V.MEM.LD.REG/1: NO(0), LOAD(1)
V.SR.LD.REG/1: NO(0), LOAD(1)
AGEX ADDR1MUX/1: NPC ;select value from AGEX.NPC
BaseR ;select value from AGEX.SR1(BaseR)
ADDR2MUX/2: ZERO ;select the value zero
offset6 ;select SEXT[IR[5:0]]
PCoffset9 ;select SEXT[IR[8:0]]
PCoffset11 ;select SEXT[IR[10:0]]
LSHF1/1: NO(0), 1bit Left shift(1)
ADDRESSMUX/1: 7.0 ;select LSHF(ZEXT[IR[7:0]],1)
ADDER ;select output of address adder
SR2MUX/1: SR2 ;select from AGEX.SR2
4.0 ;IR[4:0]
ALUK/2: ADD(00), AND(01)
XOR(10), PASSB(11)
ALU.RESULTMUX/1: SHIFTER ;select output of the shifter
ALU ;select tput out the ALU
LD.MEM/1: NO(0), LOAD(1)
MEM DCACHE.EN/1: NO(0), YES(1) ;asserted if the instruction accesses memory
DCACHE.RW/1: RD(0), WR(1)
DATA.SIZE/1: BYTE(0), WORD(1)
BR.OP/1: NO(0), BR(1) ;BR
UNCON.OP/1: NO(0), Uncond.BR(1) ;JMP,RET, JSR, JSRR
TRAP.OP/1: NO(0), Trap(1) ;TRAP
SR DR.VALUEMUX/2: ADDRESS ;select value from SR.ADDRESS
DATA ;select value from SR.DATA
NPC ;select value from SR.NPC
ALU ;select value from SR.ALU.RESULT
LD.REG/1: NO(0), LOAD(1)
LD.CC/1: NO(0), LOAD(1)
UX
UX UX
LT
ED
MU ED
TA RW
EM
AC EN
UX
UX
. VA E
AP OP
BR ESU
DC ALL
SR EED
DR EED
SR ESS
DR .SIZ
LU
DC HE.
DA HE.
1M
2M
BR OP
.
AD X
LD G
N
U. R
AD 1
.CC
. OP
.RE
DR
DR
DR
CO
.
UK
AC
.ST
1.N
2.N
2M
HF
AD
UN
AL
AL
LD
TR
SR
LS
000000 (0)
000001 (1)
000010 (2)
000011 (3)
000100 (4)
000101 (5)
000110 (6)
000111 (7)
001000 (8)
001001 (9)
001010 (10)
001011 (11)
001100 (12)
001101 (13)
001110 (14)
001111 (15)
010000 (16)
010001 (17)
010010 (18)
010011 (19)
010100 (20)
010101 (21)
010110 (22)
010111 (23)
011000 (24)
011001 (25)
011010 (26)
011011 (27)
011100 (28)
011101 (29)
011110 (30)
011111 (31)
100000 (32)
100001 (33)
100010 (34)
100011 (35)
100100 (36)
100101 (37)
100110 (38)
100111 (39)
101000 (40)
101001 (41)
101010 (42)
101011 (43)
101100 (44)
101101 (45)
101110 (46)
101111 (47)
110000 (48)
110001 (49)
110010 (50)
110011 (51)
110100 (52)
110101 (53)
110110 (54)
110111 (55)
111000 (56)
111001 (57)
111010 (58)
111011 (59)
111100 (60)
111101 (61)
111110 (62)
111111 (63)