Steam Community :: Guide :: [Guide] 🔐 Storage Cracker Solution: Binary Search in Assembly 🚀

Store Page

Turing Complete

All Discussions Screenshots Artwork Broadcasts Videos News Guides Reviews

Turing Complete > Guides > xIceFox's Guides

Not enough ratings

[Guide] 🔐 Storage Cracker Solution: Binary Search in Assembly 🚀

By xIceFox and 1 collaborators

This guide walks you through how to beat Storage Cracker using a super-fast binary search written in assembly. It includes:

• An implementation of a right shift operator (>>) for your ALU

• A self-contained, clean binary search program with constants and labels

• A one-liner minimal solution at the end for the lazy folks (no shifter needed!)

Since I didn’t find a proper guide on how to solve this level with a full assembly algorithm, I wrote one myself. Enjoy!

Award

Created by

MOD
Offline

xIceFox
Offline

Category: Walkthroughs

Languages: English

Posted

Updated

28 Mar @ 2:12am

28 Mar @ 2:17am

67	Unique Visitors
2	Current Favorites

Guide Index

Overview

🔐 Introduction

🔧 ALU Extension: Add a Right Shift Operator (>>)

🧠 Instruction Encoding Trick

📜 Binary Search Program

💡 Why This Midpoint Formula?

🎁 Bonus: One-Liner Solution (No Shift Needed)

Comments

🔐 Introduction

In this guide, I’ll show you how to pass the level Storage Cracker using the fastest possible assembly algorithm: binary search. There are plenty of great explanations on how binary search works (Here’s a great explanation of binary search on YouTube), so I won’t go into the general theory too much. Feel free to ask questions in the comments!

🔧 ALU Extension: Add a Right Shift Operator (>>)

To implement binary search efficiently, your CPU needs a right shift operation. You can add this to your ALU, which has two unused command bits available. The logic is simple: right shifting a byte is the same as dividing it by 2 and flooring the result (i.e., discarding the decimal).

💡 Hint: Shifting right is useful for halving the range in binary search.

📐 How to Add It

1. Go into the Component Factory level (in your level tree).
2. Build a component that takes a byte and shifts it one bit to the right.

3. Wire it into your ALU:

Connect the first ALU input to the new shifter.
Activate the output when the decoded command bit 6 is set (lime wire).

Now when the ALU command byte is set to 6, it will apply the right shift to the first input (reg1 in the CPU).

🧠 Instruction Encoding Trick

💡 MOV: The instruction mov + f*X + Y is a compact way to encode “copy regX to regY” using the constant f = 8, to shift the first address 3 bits to the left. This reduces the number of constants and hardcoded instructions in your program.
Shoutout to r/TuringComplete on reddit for the optimization — it’s super handy!

📜 Binary Search Program

# This program implements a binary # search algorithm to find the # correct passcode for this level. # It uses an extended ALU with a # binary right shift operation. # # The program is completely # self-contained, meaning you # do not need to copy any of # the assembly codes I used. # # Commands: # mov+f*x+y -> mov regx to regy # jgz -> jump to address in reg0 # if reg3 greater zero # jmp -> jump to address in reg0 # add -> add reg1 and reg2 # sub -> subtract reg1 and reg2 # shiftr -> right shift reg1 byte # 1 to 63 -> copy number to reg0 # # Fixed registers: # reg4 = lower bound of search # reg5 = upper bound of search # # Constants: # f: constant to shift number by # 3 to the left when multiplied # with. Used for simplifying # mov command. const f 8 # mov: constant for copy command const mov 128 # add: constant for add command const add 68 # sub: constant for sub command const sub 69 # shiftr: constant for shift right # command const shiftr 70 # jmp: constant for jmp command const jmp 196 # jgz: constant for jgz command const jgz 199 # binary search program # maximum input (via immediate) # from program into reg0 is 63. # workaround: input 255 by # calculating overflow: 0-1=255 1 mov + f*0 + 2 sub # set upper bound to 255 mov + f*3 + 5 # check boundaries as solution mov + f*4 + 6 mov + f*5 + 6 label loop # find middle: # middle=lower+((upper-lower)//2) # hint: shiftr is //2 in binary # calculate distance between upper # and lower mov + f*5 + 1 mov + f*4 + 2 sub # half the distance and floor mov + f*3 + 1 shiftr # add half distance to lower bound mov + f*4 + 1 mov + f*3 + 2 add # cache middle in reg 1 mov + f*3 + 1 # try middle as passcode mov + f*3 + 6 # copy hint to jgz input mov + f*6 + 3 # jump if too high too_high jgz # else set lower bound to middle mov + f*1 + 4 # restart loop loop jmp label too_high # set upper bound to middle mov + f*1 + 5 # restart loop loop jmp

💡 Why This Midpoint Formula?

middle = lower + ((upper - lower) // 2)

Instead of:

middle = (lower + upper) // 2

We use the first version because the second risks byte overflow (255 max). If lower + upper > 255, it wraps around to 0, breaking the logic. By calculating the difference first, we stay safely within byte range.

🎁 Bonus: One-Liner Solution (No Shift Needed)

If you’re just here to pass the level and don’t care about ALU extensions, here’s a compact solution:

1 130 3 68 158 153 196