diff --git a/src/main.zig b/src/main.zig
index 5d4b427..50a9711 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -38,6 +38,7 @@ const BitWalker = struct {
     // TODO direction
     fn walk(self: *Self, bits: u3) !u8 {
         if (bits > 8 or bits == 0) return error.invalid_bit_number;
+
         var byte = self.data.ptr[self.position];
 
         // jumps over bytes
@@ -45,26 +46,29 @@ const BitWalker = struct {
             // Generate a mast that covers the last part of the old byte
             var old_mask: u8 = 0;
             var i: usize = 0;
-            while (i < bits - self.in_byte_position) : (i += 1) {
+            while (i < 8 - @as(u4, self.in_byte_position)) : (i += 1) {
                 old_mask = @shlExact(old_mask, 1) + 1;
             }
             old_mask = @shlExact(old_mask, self.in_byte_position);
 
             var next_byte = self.data.ptr[self.position + 1];
-            var new_byte_pos: u3 = self.in_byte_position + bits % 8;
+            var new_byte_pos: u3 = @intCast(u3, @as(u4, bits) - (8 - @as(u4, self.in_byte_position)));
 
             var new_mask: u8 = 0;
             var j: usize = 0;
             while (j < new_byte_pos) : (j += 1) {
                 new_mask = @shlExact(new_mask, 1) + 1;
             }
-            print("{} mask: {b}, new_mask", .{ bits, old_mask, new_mask });
-            print("here {b} {b}", .{ byte, old_mask });
-            print("here_new {b} {b}", .{ next_byte, new_mask });
+            //print("{} mask: {b}, new_mask: {b}", .{ bits, old_mask, new_mask });
+            //print("here {b} {b}", .{ byte, old_mask });
+            //print("here_new {b} {b}", .{ next_byte, new_mask });
+
+            var result = @shrExact(byte & old_mask, self.in_byte_position) + @shlExact(next_byte & new_mask, @intCast(u3, 8 - @as(u4, self.in_byte_position)));
 
             self.position += 1;
             self.in_byte_position = new_byte_pos;
-            return byte & old_mask + next_byte & new_mask;
+
+            return result;
         }
 
         // Generate a mast that covers the last part of the old byte
@@ -75,14 +79,15 @@ const BitWalker = struct {
         }
         old_mask = @shlExact(old_mask, self.in_byte_position);
 
-        if (self.in_byte_position + bits == 8) {
-            self.position += 1;
-            self.in_byte_position = 0;
-        }
-
         const result = @shrExact(byte & old_mask, self.in_byte_position);
 
-        self.in_byte_position += bits;
+        const sum = @intCast(u4, self.in_byte_position) + @intCast(u4, bits);
+        if (sum == 8) {
+            self.position += 1;
+            self.in_byte_position = 0;
+        } else {
+            self.in_byte_position += bits;
+        }
 
         return result;
     }
@@ -164,22 +169,11 @@ const ZipFileHeader = struct {
 
         var bitw = BitWalker.init(&self.compressed_content, false);
 
-        var lastBlock1 = try bitw.walk(1);
-        var blockType1 = try bitw.walk(2);
-        var number_of_literal_codes1 = try bitw.walk(5);
-        var number_of_dist_codes1 = try bitw.walk(5);
-
-        print("{} {} {} {}", .{ lastBlock1, blockType1, number_of_literal_codes1, number_of_dist_codes1 });
-
-        var byte = self.compressed_content[0];
-        var lastBlock = byte & 0b0000_0001 == 0b0000_0001;
-        var blockType = @shrExact(byte & 0b0000_0110, 1);
-        var number_of_literal_codes = @shrExact(byte & 0b1111_1000, 3); // 256
-        byte = self.compressed_content[1];
-        var number_of_dist_codes = byte & 0b0001_1111;
-        var next_byte = self.compressed_content[2];
-        var number_of_length_codes = @shrExact(byte & 0b1110_0000, 5) + @shlExact(next_byte & 0b0000_0001, 3);
-        byte = next_byte;
+        var lastBlock = try bitw.walk(1) == 1;
+        var blockType = try bitw.walk(2);
+        var number_of_literal_codes = try bitw.walk(5);
+        var number_of_dist_codes = try bitw.walk(5);
+        var number_of_length_codes = try bitw.walk(5);
 
         if (lastBlock) {
             print("last block", .{});