Simply turn the input on/off in the upper left corner to complete the level.

---

The logic of the NAND gate lies in the fact that the only time it does not output a signal is when both of its inputs are "on."

---

The logic of the NOT gate (otherwise known as an inverter) is that it simply reverses whatever signal it receives. In other words, if it receives an "on" signal, it outputs an "off" signal; and vice versa, it outputs "on" when it receives an "off" signal.

Quite literally any[/i] other logic gate can be created with a combination of NOT and NAND gates. And all of the simple gates can be created by simply inverting (NOTing) either the inputs, the outputs, or both.

---

AND Gate

The AND gate is simply the opposite of the NAND gate. In other words, it outputs an "on" signal only when both of its inputs receive an "on" signal. This can be achieved by simply placing an inverter after a NAND gate.

---

NOR Gate

The logic of the NOR gate is simply the opposite of the OR gate. In other words, it outputs an "on" signal only when neither of its inputs receives an "on" signal. This can be achieved by inverting both input and output of a NAND gate.

---

OR Gate

Much like the NAND/AND relation, NOR/OR are simply opposites of each other. The OR gate will output an "on" signal as long as any of its inputs are on. This can be achieved by simply removing the inverter after the NAND in the NOR gate schematic.

---

Always On

As its name suggests, the logic of the Always On always outputs an "on" signal. This can be achieved by using a NOT gate tied to one of the inputs of an OR gate.

---

Second Tick

Again, as its name suggests, the logic of the Second Tick only outputs an "on" signal during the second tick of tests. In other words, when its first input receives an "on" signal and its second input receives an "off" signal. This can be achieved by using a NOT gate tied to the second input of an AND gate.

---

XOR Gate

Slightly different from the OR gate, the XOR gate still outputs "on" when either of its inputs receives an "on" signal; however, it outputs an "off" when both inputs receive an "on" signal. In other words, OR > AND < NAND.

---

Bigger OR Gate

This is simply a larger version of the OR gate that receives three inputs. It outputs an "on" signal when at least one of its inputs receives an "on" signal. Larger versions of a single gate can be created by combining multiple of the same gate.

---

Bigger AND Gate

Much like the Bigger OR gate, this one is simply a larger version of the AND gate. It outputs an "on" signal only when all three of its inputs receive "on" signals.

---

XNOR Gate

This gate is simply the opposite of the XOR gate. It outputs an "on" signal when its two inputs are identical; regardless of what their actual value is. Much like the other opposites; this can be achieved by inverting the output of an XOR gate.

---

Due to the random nature of the questions, it is difficult to show images of solutions for this level. To put it simply, You are given eight inputs (referred to as bits) you just need to add the correct bits in order to reach the total required. For example, if we think of the bits as being either "1" or "0" and we understand that each bit has a value equal to a power of 2, then we can read each bits value as follows:

Using this table, we can find the value of any 8 bit number by simply adding. For example:
Due to the fact that this level gives you a specified amount of time to answer each question, it may be difficult at first; but you don't lose the game for losing the level, so feel free to attempt as many times as necessary.

---

The logic for Double Trouble is that it simply requires you to output an "on" signal when at least two of the inputs are receiving an "on" signal.

---

Much like the previous level, this one requires an "on" signal output when the inputs receive a particular number of "on" signals. The difference here is that we only output an "on" signal when an odd number of inputs receive an "on" signal. In other words, when either 1 or 3 inputs are "on" we output an "on" signal.

---

As the name suggests, this level requires us to count the input signals. The output component has 3 nodes on it and operates much like a Byte Maker; the first (top) node has a value of 1, the second (middle) has a value of 2, and the third (bottom) has a value of 4.

---

As the name suggests, this level performs addition using the inputs. Everything is computed in binary; meaning that "1+1=2" is written as "01+01=10" with one output called "SUM" being the main value (for if the value is 0 or 1) and the other output called "CAR" being the carry (for if the value is 2).

---

As the name suggests, in this level you simply have to double the value of whatever the input is. With the provided Byte Splitter/Byte Maker components, this is extremely easy; as you can simply pass each bit to its doubled value bit (i.e. 1 to 2, 2 to 4, 4 to 8, and so on).

---

Much like Half Adder, this level performs addition using the inputs. The difference is that it uses a total of three inputs/bits; so, now we can have a value of three with the "SUM" output still being for values of 0 (off) or 1 (on) and the "CAR" output still being the carry for when we have a value of 2 (when it's on). Due to the composition of the components, both "SUM" and "CAR" can be on at the same time, making the total value of three.

---

Much like the name suggests, this level simply ORs each pair of corresponding bits within two byte values.

---

Much like the name suggests, this level simply NOTs each individual bit within a byte value.

---

Much like the name suggests, this level adds together two byte values using Full Adder components for each pair of bits.

---

This level is much like the previous Binary Racer level; however, this time, you have to represent negative numbers in binary. Every possible value from 0 to 127 is the exact same as before (ie: 00000000 to 01111111. The difference, is that now the left most bit represents -128 instead of 128. This level requires some relatively quicker math skills than Binary Racer did, and therefore is somewhat more difficult; but you again can try as many times as you need until you can successfully get high enough to proceed.

---

In order to understand the logic of this level, you need to understand 2's Complement. Basically, 2's Complement simply inverts a value, and then adds one to it in order to get the negative of the original value. So, 00100101 (a value of 15) is first negated, making it 11011010, and then has one added to it, making it 11011011 (the binary equivalent of -15).

---

Here, the problem is to have one output turned on when the input is off, and have the other output turned on when the input is on. The solution is to incorporate a NOT gate on one output and have a straight feed to the other.

---

Here, we have a similar problem to the previous level; however, instead of choosing between 2 outputs using a single input, we have to choose between eight outputs using three inputs.

---

Here is where we put everything together. We incorporate decoders and byte-gates to create a logic engine capable of doing OR, NOR, AND, and NAND operations on two different byte arguments.

---

This is a tutorial level that simply requires you to create a circuit whose input depends on it's output. There are two checks; one where it checks if there's a circular dependency, and another where it checks if you've used at least two components.

---

This level introduces a component that delays the output of its input. The solution is to simply place two of them in a row.

---

This level is somewhat bizarre. The requirement is to have a circuit that outputs an "on" signal only during every other tick (starting with the second tick). The solution is to have a Delay Line component feed itself through a NOT gate; and have the output take the feed from the Delay Line; meanwhile, ignoring the Input component entirely.
Fun Fact: The is basically the implementation of a "clock" circuit; the more delays you have in the circuit, the more ticks between pulses.

---

In this level, the goal is to create an XOR circuit using only two NOT gates and two SWITCH components. The SWITCH component is special because of its grey output pin, which signifies that it is not outputting anything as long as the switch itself is not enabled; meaning that multiple switch outputs can be connected to the same wire/component as long as only one switch is enabled at any given time.

---

This level is a bit of a riddle; you are required to output the opposite of the "Value" bit whenever the "Invert" bit is active, and simply output the "Value" otherwise. With close enough attention though, it becomes fairly obvious that the desired result is the exact same output as an XOR gate.

---

This level is very similar to the Bit Switch level; however, instead of switching between two bits, we're switching between two bytes.

---

In this level, we have two byte inputs, two byte outputs, and two bit inputs. The values of the two bit inputs determine which byte input we want to pass to which byte output. The concept of a bus is simply a wire that can hold a value from multiple separate sources; however, it still can only hold one value at a time. By using SWITCH components and NOT gates, we can create a controllable bus circuit.

---

Previously, we were able to use the Delay Line component to "save" a bit of information for a limited amount of time. The goal in this level is to actually save a bit of information indefinitely.
NOTE: For some reason, my previous solution to build a D-latch worked; but no longer works. Now, the working solution is to use a pair of switches and a not gate to, basically, simulate the function of a D-latch.

---

Using the new memory component; our goal in this level is to save an entire byte of data, and output said byte on command.

---

This level requires us to construct an operating set of four bytes of memory (essentially, four bytes of RAM) within a limited amount of space. Although somewhat difficult, it is entirely possible.
NOTE: My solution, though it works, is not particularly pretty. If anyone has a more aesthetically pleasing solution; I'm more than happy to verify and use it within this guide.

---

Here, as the level name suggests, we are required to construct a counter. Our counter must be able to not only count, but also overwrite the count value on command.

---

Here, we are required to modify our Logic Engine and incorporate the ability to add and subtract two inputs. The solution is relatively easy; we simply have to add a couple of byte adders (one of them with a byte negation before its input) and add some new switches to toggle those results.

---

Here, we simply need to create a circuit that can copy a value from a particular source to a particular destination. We have a byte input for our instruction; along with a byte input and a byte output for values. For the instruction byte, we only really care about the first six bits. The first three represent the destination, while the second three represent the source. The instruction details are as follows:
The catch to this level is only that we are not allowed to move the red components; however, we have plenty of space to create our circuit so this does not actually make the level any more difficult.