Dig deeper into the bonkbly instruction set.
						Bonkbly is a JavaScript simulated instruction set. 
						The instruction set implements basic calculations on integers and flow control instruction.
                        Bonkbly only supports 2-complement 32-bit integers and labels. 
						The integers can be used to perform basic integer calculations. 
						Labels are used to jump to specific locations in the code.
                        The entry point for each Bonkbly programm is the label main.
						If this label is not defined, the programm starts executing the instruction at the top of the file.
					
An instruction in Bonbkly starts with the instruction name, followed by a number of arguments. For most instructions, these arguments can be either a number or a register/variable Some instructions require specific arguments to be a register/variable.
						The control instructions jmp, jz and jnz 
						require a label as argument.
					
						An example of the add and jmp instructions are given below:
					
add 12 12 $value
jmp main
					Bonk supports line comments. Start a line comment by using double dashes:
-- This is a comment
					The syntax for labels is as follows, note that the colon is required:
label main:
					Bonk is case-insensitive, uses a newline as instruction terminator and every line can contain any number of trailing and/or leading whitespaces. The following example is, although horribly cursed, valid syntax:
label main:
	           MoV 0 $vAlEu
	AdD 12 $VaLuE $value
	LABEL LoOp:
					  mOV 12 $other_value
add $VALUE $OTHER_VALUE $24value
					$vAlEu, $VALUE, $VaLuE and $value all point to the same register.
					$24value is a valid register name, just like $24.
					Bonkbly does not require an instruction to follow a label definition, it also does not require an indent to take place:
-- Entry point to programm
label main:
label loop:
	mov 0 $i
	add 1 $i $i
	-- Do stuff
label end:
mov 12 $value
				This part will give an overview of the coding conventions used in Bonkbly. These will try to keep your code readable.
					    As stated in the introduction, 
						the entry point for each program is where the main label is defined. 
						It is advised to always define this label, because if this label is not defined, 
						the program will start executing the first instruction in the file.
						Furthermore, it is advised to indent every instruction, 
						as this greatly improves readability.
					
label for_loop:
	add 1 $i $i
	-- Do stuff
	cmp $i 12
	jnz for_loop
label main:
	mov 0 $i
	jmp for_loop
					
					A short description of what a label implements can be given just above the label using a line comment, e.g.:
-- Return location for for loop
label for_loop:
					
					Subfunctionalities in functions can be indented further. However, every label is a global label, so the same label cannot be used twice.
label for_loop:
	add 1 $i $i
	-- Do stuff
	mov 0 $j
	label for_loop_in_for_loop:
		add 1 $j $j
		-- Do stuff
		cmp $j 6
		jnz for_loop2
	
	cmp $i 12
	jnz for_loop
label main:
	mov 0 $i
	jmp for_loop
					
					Since Bonk is case-insensitive, it is advised to always use snake_case for labels and registers, rather than CamelCase or pascalCase, to avoid confusion when switching between the two.
Here you find an extended description of the bonkbly instructions.
Here you find an overview of the syscalls that were implemented. Syscalls are used to interact with the environment, in this case with Bonk.
					All of the sens syscalls (fsens, lsens, rsens and nsens) are used to sense the environment.
					These syscalls will write values to specific registers based on the tiles around the players.
					Here we will give you an overview of the valid values, and the specific registers every sens syscall writes to.
				
All of the registers used for the sens syscalls are read-only, and can only be written to by the sens syscalls. Writing to these registers will result in an error and the program will be terminated.
fsens, lsens and rsens
					For the fsens, lsens and rsens instruction, the possible values are:
				
| Value | Binary representation | Description | 
|---|---|---|
| 1 | 0b00001 | The observed tile is out of the field | 
| 2 | 0b00010 | The observed tile is a wall | 
| 4 | 0b00100 | The observed tile is a player | 
| 8 | 0b01000 | The observed tile is empty | 
| 16 | 0b10000 | The observed tile contains a powerup | 
					All values are writting to the registers $br1 to $br8.
					The specific tiles that are observed are given in the figures below.
				
								 
							 | 
							
								 
									Tiles observed by the   | 
						
								 
							 | 
							
								 
									Tiles observed by the   | 
					
					The nsens (near sens) instruction observes the tiles around the player.
					All tiles less than 2 tiles away from the player are observed.
					It will check if a player, a wall, the edge of the field or a powerup is present.
					The values are written to specific registers.
				
| Register | Description | 
|---|---|
| $player_nearby | This register is set to 1 if a player is nearby (not including the bot itself). | 
| $wall_nearby | This register is set to 1 if a wall is nearby. | 
| $edge_nearby | This register is set to 1 if the edge of the field is nearby. | 
| $powerup_nearby | This register is set to 1 if a powerup is nearby. | 
					To help you code your bot, we added 2 extra variables: $health and $tick.
					These variables allow you to take a look at your current health, and keep track of the current tick.