// Hi! If you're reading this, you probably want to know what this program does
// To that, I say: Good luck and I hope you have patience and a strong will to
// live, 'cause both will be negatively impacted by trying to read the code
// below.
// This isn't a joke; I feel like someone telling a person to get off the edge
// of a tall building here: reading the code below WILL negatively impact your
// life. You have been warned.

// For clarity's sake, I thought I'd add a small preface here:
// We use the optable as a replacement for a hashing algorithm. Check the
// #optable directives if you're wondering what bucket the 4 highest bits of a
// value end up pointing to. Each entry in the optable simply loads the
// address of the corresponding bucket and initiates an insertion sort for said 
// bucket.
// Labels ending in "_SPEC" are edge-case optimization labels. They are
// branched to in the case of special edge cases with the idea being that they
// are much faster than following the reguar code-path (even if said path would
// ultimately perform the same action).
// For example, "call @JTABLE_SPEC" invokes a special jumptable subroutine
// which parallelizes some of the boilerplate needed for the upcoming merge.


#define LIST_START 0xE0
#define LIST_END 0x00
#define HIGHEST_BUCKET 0x78
#define BUCKET_SIZE 8
#define BUCKET_INDEX_TRACKER 0b11111000

#optable 0x0 @OT_0
#optable 0x1 @OT_1
#optable 0x2 @OT_2
#optable 0x3 @OT_3
#optable 0x4 @OT_4
#optable 0x5 @OT_5
#optable 0x6 @OT_6
#optable 0x7 @OT_7
#optable 0x8 @OT_8
#optable 0x9 @OT_9
#optable 0xa @OT_A
#optable 0xb @OT_B
#optable 0xc @OT_C
#optable 0xd @OT_D
#optable 0xe @OT_E
#optable 0xf @OT_F

// Set up buckets (with absolute sizes)
// Bucket count: 16
// Bucket size: 8
// Motivation: direct mapping from hash to bucket at the cost of bucket size
#data 0x00 0x00 // 0 (POSITIVE)
#data 0x08 0x00 // 1 (POSITIVE)
#data 0x10 0x00 // 2 (POSITIVE)
#data 0x18 0x00 // 3 (POSITIVE)
#data 0x20 0x00 // 4 (POSITIVE)
#data 0x28 0x00 // 5 (POSITIVE)
#data 0x30 0x00 // 6 (POSITIVE)
#data 0x38 0x00 // 7 (POSITIVE)
#data 0x40 0x00 // 8 (NEGATIVE)
#data 0x48 0x00 // 9 (NEGATIVE)
#data 0x50 0x00 // A (NEGATIVE)
#data 0x58 0x00 // B (NEGATIVE)
#data 0x60 0x00 // C (NEGATIVE)
#data 0x68 0x00 // D (NEGATIVE)
#data 0x70 0x00 // E (NEGATIVE)
#data 0x78 0x00 // F (NEGATIVE)


// Set all GR-registers to -1, so that we always can call "sub gr" to increment
// AR, no matter what value we have in IR ;)
const 0xB00         // GRx=10, M=11
lsr; mov ar ir
lsr; reset gr
lsr; reset grm
mov ar ir           // GRx=00, M=01
reset gr
reset grm

// Initialize PC to point at list
const LIST_START
mov ar pc
mov pc asr; incpc

// Perform bucketsort for 32 elements
mov pm ir; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE

mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; incpc; call @JTABLE
mov pm ir; call @JTABLE_SPEC


//call @BREAK


// Initialize state for merge
const BUCKET_SIZE
mov ar hr
const HIGHEST_BUCKET


// Do the merge thing
$MERGE

// Load bucket size into LC
mov ar asr
mov pm lc

// Copy elements to list
$MERGE_MOVE
sub gr; declc; bls @MERGE_BOTTOM    // AR -= -1, branch if there are no more
                                    // elements to copy
mov ar asr
mov pm ir
mov pc asr; incpc; bls @MB_SPEC     // This branch improves stability
mov ir pm; bra @MERGE_MOVE          // Transfer value and copy more elements

$MB_SPEC
mov ir pm                           // Transfer value and go to next bucket

// Check if we just copied the last bucket
$MERGE_BOTTOM
and BUCKET_INDEX_TRACKER            // Mask out element index (lowest 3 bits)
sub hr; bnz @MERGE                  // Compute index of next bucket and stuff


// Breakpoint hook and program termination point
$BREAK
halt




// Jump-table subroutine
$JTABLE
mov pc hr; bop

$JTABLE_SPEC
const LIST_START
mov ar hr; bop

// IR OP-field jump table
$OT_0
const 0x38
mov ar asr; bra @PREPARE_SORT

$OT_1
const 0x30
mov ar asr; bra @PREPARE_SORT

$OT_2
const 0x28
mov ar asr; bra @PREPARE_SORT

$OT_3
const 0x20
mov ar asr; bra @PREPARE_SORT

$OT_4
const 0x18
mov ar asr; bra @PREPARE_SORT

$OT_5
const 0x10
mov ar asr; bra @PREPARE_SORT

$OT_6
const 0x08
mov ar asr; bra @PREPARE_SORT

$OT_7
const 0x00
mov ar asr; bra @PREPARE_SORT

$OT_8
const 0x78
mov ar asr; bra @PREPARE_SORT

$OT_9
const 0x70
mov ar asr; bra @PREPARE_SORT

$OT_A
const 0x68
mov ar asr; bra @PREPARE_SORT

$OT_B
const 0x60
mov ar asr; bra @PREPARE_SORT

$OT_C
const 0x58
mov ar asr; bra @PREPARE_SORT

$OT_D
const 0x50
mov ar asr; bra @PREPARE_SORT

$OT_E
const 0x48
mov ar asr; bra @PREPARE_SORT

$OT_F
const 0x40
mov ar asr; bra @PREPARE_SORT



// Actual bucketsort
$PREPARE_SORT
mov pm pc; mov pm lc                    // Load bucket length
sub gr; incpc                           // Increment bucket length
mov pc pm; bls @IE_SPEC                 // Store new length

mov ar pc; sub ar
sub ir // Save -IR into AR (you'll see why)


$INSERTION
mov pc asr; incpc; declc; bls @INSERTION_END_BIGGEST
add pm                  // Effectively, AR=PM-IR, except more like AR=-IR+PM
sub pm; brn @INSERTION

mov pm ar
mov ir pm; bls @IEN_SPEC

$INSERTION_SHIFT
mov pc asr
mov pm ir
mov ar pm; bls @INSERTION_END_NOTBIGGEST
mov ir ar; declc; incpc; bra @INSERTION_SHIFT

$IEN_SPEC
mov pc asr
mov ar pm; bra @INSERTION_END_NOTBIGGEST

$IE_SPEC
mov ar asr

$INSERTION_END_BIGGEST
mov ir pm

$INSERTION_END_NOTBIGGEST
mov hr pc
mov pc asr; ret