Staq reverse Collatz (97 bytes)

{2&ii}&i2qqt{R[t|@-[d". "]xX|d@:2iqi;x2*X@$@RXs&+Xd2i@%(x/d[i2@%[xXXX@$@RXs&&&&&!]xX!]?)xxx@i!]}R

&[
    HI! This is a weird language. Anything enclosed like so: &[ ... ]x is a comment.
    Anyway it's called Staq. I made it ages ago and it kind of sucks, but it's fantastic
    for fitting a lot of operations into only a few characters.

    You can find Staq online here: http://esolangs.org/wiki/Staq

    Above is the code with no comments or whitespace. It's fully functional! And only 97
    bytes long. To see how it actually works you can take a look at the expanded version
    below, even run it if you're feeling adventurous.

    First, though, here's a SLIGHTLY expanded version to give a sort of overview of the
    program flow. This will run exactly as the code above.


        &[ define 2 as a function that pushes a 2 to the stack ]x
        {2&ii}

        &[ initialize with arguments: recursion depth = 16, initial value = 1 ]x
        &i2qqt

        &[ define R as a recursive function for outputting a tree of Collatz sequences ]x
        {R[
            &[ output dots followed by the current value ]x
            t|@-[d". "]xX|d@:2iqi;x

            &[ call recursively for val * 2 ]x
            2*X@$@RXs

            &[ call recursively for (val - 1) / 3 ]x
            &+Xd2i@%(x/d[i2@%[xXXX@$@RXs&&&&&!]xX!]?)xxx@i
        !]}

        &[ finally, run R ]x
        R


    And here's the full output:


        1
        . 2
        . . 4
        . . . 8
        . . . . 16
        . . . . . 32
        . . . . . . 64
        . . . . . . . 128
        . . . . . . . . 256
        . . . . . . . . . 512
        . . . . . . . . . . 1024
        . . . . . . . . . . . 2048
        . . . . . . . . . . . . 4096
        . . . . . . . . . . . . . 8192
        . . . . . . . . . . . . . . 16384
        . . . . . . . . . . . . . . . 32768
        . . . . . . . . . . . . . . . 5461
        . . . . . . . . . . . . . 1365
        . . . . . . . . . . . . . . 2730
        . . . . . . . . . . . . . . . 5460
        . . . . . . . . . . . 341
        . . . . . . . . . . . . 682
        . . . . . . . . . . . . . 1364
        . . . . . . . . . . . . . . 2728
        . . . . . . . . . . . . . . . 5456
        . . . . . . . . . . . . . . . 909
        . . . . . . . . . . . . . 227
        . . . . . . . . . . . . . . 454
        . . . . . . . . . . . . . . . 908
        . . . . . . . . . . . . . . . 151
        . . . . . . . . . 85
        . . . . . . . . . . 170
        . . . . . . . . . . . 340
        . . . . . . . . . . . . 680
        . . . . . . . . . . . . . 1360
        . . . . . . . . . . . . . . 2720
        . . . . . . . . . . . . . . . 5440
        . . . . . . . . . . . . . . 453
        . . . . . . . . . . . . . . . 906
        . . . . . . . . . . . . 113
        . . . . . . . . . . . . . 226
        . . . . . . . . . . . . . . 452
        . . . . . . . . . . . . . . . 904
        . . . . . . . . . . . . . . 75
        . . . . . . . . . . . . . . . 150
        . . . . . . . 21
        . . . . . . . . 42
        . . . . . . . . . 84
        . . . . . . . . . . 168
        . . . . . . . . . . . 336
        . . . . . . . . . . . . 672
        . . . . . . . . . . . . . 1344
        . . . . . . . . . . . . . . 2688
        . . . . . . . . . . . . . . . 5376
        . . . . . 5
        . . . . . . 10
        . . . . . . . 20
        . . . . . . . . 40
        . . . . . . . . . 80
        . . . . . . . . . . 160
        . . . . . . . . . . . 320
        . . . . . . . . . . . . 640
        . . . . . . . . . . . . . 1280
        . . . . . . . . . . . . . . 2560
        . . . . . . . . . . . . . . . 5120
        . . . . . . . . . . . . . . . 853
        . . . . . . . . . . . . . 213
        . . . . . . . . . . . . . . 426
        . . . . . . . . . . . . . . . 852
        . . . . . . . . . . . 53
        . . . . . . . . . . . . 106
        . . . . . . . . . . . . . 212
        . . . . . . . . . . . . . . 424
        . . . . . . . . . . . . . . . 848
        . . . . . . . . . . . . . . . 141
        . . . . . . . . . . . . . 35
        . . . . . . . . . . . . . . 70
        . . . . . . . . . . . . . . . 140
        . . . . . . . . . . . . . . . 23
        . . . . . . . . . 13
        . . . . . . . . . . 26
        . . . . . . . . . . . 52
        . . . . . . . . . . . . 104
        . . . . . . . . . . . . . 208
        . . . . . . . . . . . . . . 416
        . . . . . . . . . . . . . . . 832
        . . . . . . . . . . . . . . 69
        . . . . . . . . . . . . . . . 138
        . . . . . . . . . . . . 17
        . . . . . . . . . . . . . 34
        . . . . . . . . . . . . . . 68
        . . . . . . . . . . . . . . . 136
        . . . . . . . . . . . . . . 11
        . . . . . . . . . . . . . . . 22
        . . . . . . . 3
        . . . . . . . . 6
        . . . . . . . . . 12
        . . . . . . . . . . 24
        . . . . . . . . . . . 48
        . . . . . . . . . . . . 96
        . . . . . . . . . . . . . 192
        . . . . . . . . . . . . . . 384
        . . . . . . . . . . . . . . . 768


    And, without further ado, the fully expanded code. This is how I wrote it, the
    whitespaceless and commentless code came after. This will also run exactly as
    the code above.


        &[ define func: push a 2 to the stack ]x
        {2 &ii}

        &[ set initial stack state to ( 16, 1 ) ]x
        &i2qq

        &[ before execution, copy the top value (16) to the ALT stack ]x
        t

        &[ define and call recursive function ]x
        &[ expects initial stack ( itr, val, ... ) with ALT stack ( initial val ) ]x
        {R

            &[ if itr > 0 ]x
            [

                &[ output dots to console ]x

                    &[ get num dots to output ]x
                    t|      &[  ALT: itr, init              ]x
                    @       &[  ALT: init, itr              ]x
                    -       &[  ALT: init-itr, init, itr    ]x

                    &[ while( num-- ) print ". " ]x
                    [d". "]

                    &[ reset ALT stack ]x
                    x       &[  ALT: init, itr  ]x
                    X|      &[  ALT: init       ]x

                &[ itr-- ]x
                d

                &[ reorganize ]x
                @       &[  val, itr, ...           ]x

                &[ print val ]x
                :

                &[ print a newline ]x
                2iqi;x

                &[ push val*2 ]x
                2*X     &[  val*2, val, itr, ...    ]x

                &[ reorganize ]x
                @       &[  val, val*2, itr, ...    ]x
                $       &[  val*2, itr, ..., val    ]x
                @       &[  itr, val*2, ..., val    ]x

                &[ call recursively ]x
                R

                &[ remove val*2 and undo reorganize ]x
                X       &[  itr, ..., val    ]x
                s       &[  val, itr, ...    ]x

                &[ push val-1 ]x
                &+X     &[  val, val, itr, ...      ]x
                d       &[  val-1, val, itr, ...    ]x

                &[ push (val-1)%3 ]x
                2i      &[  3, val-1, val, itr, ...              ]x
                @       &[  val-1, 3, val, itr, ...              ]x
                %       &[  (val-1)%3, val-1, 3, val, itr, ...   ]x

                &[ if (val-1)%3 == 0 ]x
                (

                    &[ push (val-1)/3 ]x
                    x       &[  val-1, 3, val, itr, ...               ]x
                    /       &[  (val-1)/3, val-1, 3, val, itr, ...    ]x

                    &[ if (val-1)/3 > 1 ]x
                    d[i

                        &[ push ((val-1)/3)%2 ]x
                        2       &[  2, (val-1)/3, val-1, 3, val, itr, ...                 ]x
                        @       &[  (val-1)/3, 2, val-1, 3, val, itr, ...                ]x
                        %       &[  ((val-1)/3)%2, (val-1)/3, 2, val-1, 3, val, itr, ...  ]x

                        &[ if ((val-1)/3)%2 ]x
                        [

                            &[ reorganize ]x
                            x       &[  (val-1)/3, 2, val-1, 3, val, itr, ... ]x
                            X       &[  (val-1)/3, val-1, 3, val, itr, ... ]x
                            X       &[  (val-1)/3, 3, val, itr, ... ]x
                            X       &[  (val-1)/3, val, itr, ... ]x
                            @       &[  val, (val-1)/3, itr, ... ]x
                            $       &[  (val-1)/3, itr, ..., val ]x
                            @       &[  itr, (val-1)/3, ..., val ]x

                            &[ call recursively ]x
                            R

                            &[ undo changes to stack ]x
                            X       &[  itr, ..., val ]x
                            s       &[  val, itr, ... ]x
                            &&&&&   &[  0, 0, 0, 0, 0, val, itr, ... ]x

                        !]

                        &[ undo changes to stack ]x
                        x       &[  (val-1)/3, 2, val-1, 3, val, itr, ...  ]x
                        X       &[  (val-1)/3, val-1, 3, val, itr, ...  ]x

                    !]

                ?)

                &[ undo changes to stack ]x
                x       &[  val-1, 3, val, itr, ... ]x
                x       &[  val-1, val, itr, ...   ]x
                x       &[  val, itr, ... ]x
                @       &[  itr, val, ... ]x

                &[ undo itr-- ]x
                i

            !]

        }R


]x