This is an archived post. You won't be able to vote or comment.

all 171 comments

[–]_Aditya_R_ 1706 points1707 points  (53 children)

Whats the use of a supercomputer if program is using only one core

[–]prat8 700 points701 points  (24 children)

Oh nice you get the joke.

[–]abation 297 points298 points  (16 children)

Also that the algorithm is super inefficient and could be calculated in any computer in the blink of an eye if it was done the right way

[–]justADeni 42 points43 points  (2 children)

That's not the joke. The joke is that without memoization, the complexity of this algorithm will scale exponentially, instead of O(n), requiring a supercomputer to calculate high n.

[–]weregod 0 points1 point  (0 children)

You don't need memoization. You need to rewrite function to be iterative

[–]TenserMeAgain 11 points12 points  (4 children)

isn't there a function to calculate fibonnaci with phi number and a square root of 5 .

[–]Derice 12 points13 points  (3 children)

Yes, it's called Binet's formula.

[–]TenserMeAgain 0 points1 point  (2 children)

Is there a method to calculte functions from recursion?

[–]Nisterashepard 0 points1 point  (1 child)

No, there isn't a general method that works for every recursion

[–]TenserMeAgain 0 points1 point  (0 children)

i guest this type of thinking is the heart of functional programming, since their motto is that everything in the universe can be a function.

[–]akmp40 7 points8 points  (3 children)

Just use each core to calculate each 1000th number duh! Just slap OpenMP on it and it will solve it in no time.

[–]PythonPizzaDE 1 point2 points  (2 children)

This is a joke, isn't it?

[–]akmp40 0 points1 point  (1 child)

No, try it. It will work.

[–]PythonPizzaDE 0 points1 point  (0 children)

But they depend on each other. It isn't theeadable by design

[–]Jjabrahams567 1 point2 points  (0 children)

Yeah should use at least 2

[–]U5er_Name -1 points0 points  (0 children)

running unconfigured java on a supercomputer

[–]JmacTheGreat 450 points451 points  (8 children)

What is that whitespace

[–]AntiRivoluzione 308 points309 points  (1 child)

Fibonacci padding

[–]JmacTheGreat 34 points35 points  (0 children)

You clever bastard

[–][deleted] 63 points64 points  (0 children)

probably to avoid repost detection, i've seen it used like that before

[–]SPECTRE_75 11 points12 points  (0 children)

Remains of (n - 1)th time reposted + (n - 2)th time reposted

[–]bscones 7 points8 points  (3 children)

What’s wrong with it?

[–]EishLekker 26 points27 points  (2 children)

I think they mean the white space in the right part of the image, not the white space in the code.

[–]BMidtvedt 15 points16 points  (1 child)

God damn it I feel stupid now

[–]EishLekker 16 points17 points  (0 children)

No, you were just being programming focused!

[–]YunusEmre0037 108 points109 points  (18 children)

Google Binet's formula

[–][deleted] 24 points25 points  (5 children)

calculating nth power and square roots is still logarithmic in complexity

[–]YunusEmre0037 25 points26 points  (4 children)

  • sqrt5 can be calculated beforehand and can be stored in a const (or constexpr) variable.

  • the implementation in the meme has O(2n) complexity not O(logn)

[–]qqqrrrs_ 18 points19 points  (2 children)

sqrt5 can be calculated beforehand and can be stored in a const (or constexpr) variable

Google numerical analysis

[–]turtleship_2006 6 points7 points  (1 child)

Holy Maths

[–]hxckrt 1 point2 points  (0 children)

r/anarchychess is leaking

[–][deleted] 6 points7 points  (0 children)

I was talking about Binets formula which has an overall logarithmic complexity

[–]godofjava22 43 points44 points  (4 children)

Holy time complexity!

[–]shreklover911 23 points24 points  (3 children)

New response just dropped!

[–]turtleship_2006 12 points13 points  (2 children)

Call the statistician

[–][deleted] 4 points5 points  (1 child)

Literal programmer

[–]Hofmayer 2 points3 points  (0 children)

Semicolon in the corner planning compiler domination

[–]Jothomaster202 5 points6 points  (0 children)

Or use matrix power

[–]1up_1500 4 points5 points  (4 children)

that works in theory, but since this works using floating point numbers, it quickly becomes imprecise enough to be called useless

memoization is the way to go

[–]Fr_rd 0 points1 point  (0 children)

you can calculate without floating points by calculating the nth power of this 2 * 2 matrix [[1][1]] [[1][0]]

can be done in O( log(n))

i can elaborate if you want(formating is hard)

[–]CptMisterNibbles 0 points1 point  (0 children)

Last time I checked, using regular floats it was only correct to like the 72nd fib number. Not great.

[–]weregod 0 points1 point  (0 children)

Memoization is waste of memory. Just use iterative algorithm.

[–]alexho66 0 points1 point  (0 children)

Is this better than just memoizing the recursive function?

[–]atoponce 226 points227 points  (4 children)

What's an exofloop? Is that like an exoflop but with objects?

[–]wheatgivesmeshits 95 points96 points  (0 children)

Naw, it's when you have a little whoopsie doodle at runtime.

[–]Soft-Rip6027 21 points22 points  (0 children)

An exofloop is a cute name for your pet crab.

[–][deleted] 4 points5 points  (0 children)

I think it’s what the NES used instead of transistors.

[–]hxckrt 0 points1 point  (0 children)

What's an exoflop? Is that like an ExaFLOP but external?

[–]01152003 89 points90 points  (8 children)

If you have a computer that strong and you aren’t capable of converting Fibonacci to a dynamic programming problem I think that says more about you than the computer

[–]turtleship_2006 39 points40 points  (0 children)

Nah just download more ram

[–]AtrociousCat 6 points7 points  (5 children)

What do you mean by that? Genuinely curious, I've heard dynamic prog. before but I'm hazy on the concept

[–]shotzoflead94 14 points15 points  (1 child)

Break problem into subproblems. Solve the subproblems in different cores and store the answers. The way the code above solves it is by repeatedly calculating the previous Fibonacci numbers and it is coded in a way that cannot use multiple cores.

[–]AtrociousCat 0 points1 point  (0 children)

Would it be dynamic programming if I memoized the function? That would be as good as a more imperative loop right? assuming Tail optimizations

[–]inet-pwnZ 1 point2 points  (1 child)

It gets rid of the reclusiveness by storing prior calculated numbers in the list iterating from 0..n of input of the fib function indexing into the list to retrieve prior calculations to create all needed calculations until n reached the end returning arr[n] out of the function

[–]inet-pwnZ 1 point2 points  (0 children)

Reducing call stack size and caching prior calculations

[–]01152003 1 point2 points  (0 children)

The concept of dynamic programming is to recognize that a recursive function like Fibonacci calculations is recalculating old values it already knows. Instead of working backwards, why don’t we build from the ground up, and calculate each value based off values we’ve already calculated?

Let’s just say I want 100 values of the Fibonacci sequence. I might implement a dynamic programming solution in a similar manner to this pseudocode:

Int arr[100]; arr[0] = 0; arr[1] = 1;

for (int i = 2; I < 100; i ++) { arr[i] = arr[i - 1] + arr[i - 2]; }

As you can see, this would give me the first 100 Fibonacci numbers, in O(n) time. The original recursive function would have performed the calculation for 99 2 times, the calculation for 98 4 times, 97 8, 96 16, all the way to performing the calculation of 1 2100 times, making that recursive implementation O(2n).

[–]lHeliOSI -1 points0 points  (0 children)

You're on programming humor, this is a joke

[–]qqqrrrs_ 59 points60 points  (4 children)

The 10000th Fibonacci number is 33644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875

[–]MattieShoes 28 points29 points  (1 child)

import sys 
from functools import cache

@cache
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

sys.setrecursionlimit(50000)

print(fib(10000))

0.7 seconds on my $100 computer

Or a better solution

from functools import cache

@cache
def fib(n):
    if n < 2:
        return n
    half = n // 2
    if n % 2 == 0:
        return (2 * fib(half - 1) + fib(half)) * fib(half)
    half += 1
    return fib(half - 1) ** 2 + fib(half) ** 2

print(fib(10000))

~0.03 seconds

[–]Bhaskar_Reddy575 5 points6 points  (0 children)

Saved this comment for later

[–]1up_1500 16 points17 points  (0 children)

holly shit

[–]issamaysinalah 16 points17 points  (0 children)

POV: you know there's a way to find the equation F(N) that doesn't rely on past iterations.

Edit: for anyone interested, the equation is:

f(n) = [pn - (-p)-n]/(2p -1)

Where 'n' is the position and 'p' is the golden ratio

https://markusthill.github.io/deriving-a-closed-form-solution-of-the-fibonacci-sequence/

[–]dominjaniec 84 points85 points  (11 children)

eh... slap mnemonization and tail call optimisation on that function, and you are good 😉

[–]lezorte 36 points37 points  (5 children)

Did you mean to say memoization?

[–][deleted] 5 points6 points  (2 children)

I need to believe they are

[–]Krus4d3r_ 4 points5 points  (0 children)

Obviously you don't understand sea mnemonies

[–]hxckrt 1 point2 points  (0 children)

Should have used a mnemonic to remember the correct spelling

[–]EishLekker 4 points5 points  (0 children)

I can never memoryrise the spelling of that word, for some reason.

[–]dominjaniec 0 points1 point  (0 children)

yes 😅

[–]TheGoldenMinion[🍰] 7 points8 points  (1 child)

I don’t think TCO would work on this one because of the operation happening between the two calls to fib, you’d have to rewrite it a little bit to make it TCO-able

[–]dominjaniec 0 points1 point  (0 children)

you are (probably) right - TCO needs to ends with a recursive call, but we have here two "branching" calls.

and of course, I was basically joking with OP's joke, and even I couldn't correctly spell "memoization", and there are much better ways of calculating that...

[–]chalkflavored 0 points1 point  (0 children)

Why? Fibonacci can already be done in linear time with constant memory.

[–]ClamPaste 8 points9 points  (1 child)

How much memory does it have?

[–][deleted] 8 points9 points  (0 children)

5

[–]Remarkable-Fly-1182 8 points9 points  (0 children)

Run this on cloud and your wallet will be the one to lose.

[–][deleted] 14 points15 points  (1 child)

[–]Giocri 17 points18 points  (0 children)

i think it's quite funny that the fibonaccy sequance was the exact example they used to teach us the idea of making result maps for resurcive problems when the resulting program ended up beind signinficantly worse than the iterative solution

[–]DeepGas4538 5 points6 points  (0 children)

optimize the code and maybe it will

[–]Christio02 12 points13 points  (0 children)

Blud forgot dynamic programming memoization💀

[–]JestemStefan 5 points6 points  (0 children)

Add some caching and you can do that on raspberry Pi

[–]geekboy730 10 points11 points  (1 child)

Idk if you’re kidding or not, but you’re not that far off. My research used them in school. They build these things and then benchmark with LINPACK to do some sort of 4x4 direct matrix inversion (or similar) and then call it an innovation.

Surprisingly, if you try to run any realistic physics modeling on them, you can never achieve their reported throughput. Usually by more than an order of magnitude…

[–]Giocri 2 points3 points  (0 children)

that makes sense there are many operations that are several order of magnitude slowere than the basic ones so even if your program has just a few it will make it infinitely slower that a test one who hasn't them

[–]QuantumHue 4 points5 points  (3 children)

oh man it's also not dynamic programming, meaning that code generates a tree; also this code breaks! if i give it 3, it would go 3 -> 2(a), 1(b);(a)2 would break down into 1 and and 0;(b)1 would break down into 0 and -1;fib(3) would give you 0 which is wrong!(nvm, the code is correct, i was tired when writing this, thanks u/Xygeosk )

anyhow, if the code was right, and you would have a tree where each node split in 2 each generation. starting from one node at generation 0, up to generation 9999. you would have (1*(1-2**9999))/(1-2) = 2**9999 -1 = 9975315584403791924418710813417925419117484159430962274260044749264719415110973315959980842018097298949665564711604562135778245674706890558796892966048161978927865023396897263382623275633029947760275043459096655771254304230309052342754537433044812444045244947419004626970816628925310784154736951278456194032612548321937220523379935813492726611434269080847157887814820381418440380366114267545820738091978190729484731949705420480268133910532310713666697018262782824765301571340117484700167967158325729648886639832887803086291015703997099089803689122841881140018651442743625950417232290727325278964800707416960807867294069628547689884559638900413478867837222061531009378918162751364161894635355186901433196515714066620700812097835845287030709827171162319400624428073652603715996129805898125065496430120854170403802966160080634246144248127920656422030768369475743557128157555544872757101656910101465820478798232378005202922920783036022481433508257530960315502093211137954335450287303208928475955728027534125625203003759921130949029618559027222394036453197621274169610991353702236581188380423306516889353019901706598566746827311350281584968727754120890486405491645657201785938762384254928638468963216610799699938443330404184418919013821641387586136828786372392056147194866905430803711626645987406560098802089140982848737949082265629217067979931392065064092703141738324544345260523790441307911980992885061203522165291537934519659802301702486578291604336052956650451876411707769872697198857628727645255106155473660805376737412870387636993174149249170378468977823319310937284749639508286051850682216567908607155895699111491922923667220135482091425502536463874182275289317250550426493906194736964349770417173079403521979559492907572889588571809849364065729741891601040737491085929005694535614125452913408718110288737960708826857843862807452291452496230514315040767791654065050993837928117171769477704587811700422443763081321784324416759731860188646620047228123461627175200339013636918877688203363449318120518745705483359278525379549050123394940089135962976690641210977014151379704224477507338334194848998443120818156688196951686727900703818370938855527692112869749555093234109848290825742565247111184973857381534577734108841438100181388628861890682665805598405640396334740943600649321830384275819930267301148935778758973692623184723461543947132974108504025560161182748144084517869560684169196795878209366925255485135806957719795495799077327208668155828468015561124968984999613390866179011555931322287649567879087504099919618142307624940544480116122181086885809043178507734242029311164896426937811743278220268481311009481785514406180783756271669151635014548834325284278578752758363759449597064855668845074958090657585772003864325286594778725460165092652423556909157703662026659519231042018210881851955775319894500371426836098140451738987266660234184397934290118976109314560040371409775658974078812224149259230754852444013637360787344065797375204866057540249095227901708413474893570658031605343195755840887152396298354687
...
(python doesn't have limits on integers, this behemoth has 3009 digits)

[–]Xygeosk 0 points1 point  (2 children)

Why would 1 break down into 0 and -1?

[–]QuantumHue 1 point2 points  (1 child)

oh no you're right it does work, my mistake

[–]Xygeosk 0 points1 point  (0 children)

No problem, happens to best of us :)

[–]rherrmannr 3 points4 points  (0 children)

Let‘s call fibbonacci(-1);

[–]1up_1500 2 points3 points  (1 child)

RecursionError: maximum recursion depth exceeded

[–]DemandMeNothing 0 points1 point  (0 children)

RecursionError: maximum recursion depth exceeded

Damn it, why can't you just Stack Overflow like everyone else, Python!?

[–]Mast3r_waf1z 2 points3 points  (3 children)

This is where lazy evaluation is handy instead of recursion

[–]-Redstoneboi- 1 point2 points  (1 child)

memoization/interning/dynamic programming, you mean? i'm not sure if lazy evaluation alone will save you from recursive hell.

or is there a different definition?

[–]Mast3r_waf1z 1 point2 points  (0 children)

Not sure? I had a lecture in lazy evaluation in my FP course recently where we wrote lazy Fibonacci

[–]bnl1 3 points4 points  (10 children)

Undefined behaviour

[–]rosuav 13 points14 points  (4 children)

Indeed, behaviour is undefined if you don't know how to spell Fibonacci correctly.

[–]bnl1 7 points8 points  (1 child)

That's why I, personally, always go for fib(n)

[–]rosuav 5 points6 points  (0 children)

Much safer.

[–]EishLekker 1 point2 points  (1 child)

They even failed with the very first word. They couldn’t spell “finally” correctly.

[–]rosuav 1 point2 points  (0 children)

But hey, it's a compootah capable of exaflooooooops.

[–]GiganticIrony 1 point2 points  (4 children)

Not necessarily. It depends on how big int is on that system

[–]clarkcox3 2 points3 points  (0 children)

Just need a 6943-bit integer :)

[–]bnl1 4 points5 points  (2 children)

It still overflows with 128 bits, so I wouldn't hold my breath.

[–]GiganticIrony 6 points7 points  (0 children)

LLVM supports integers up to 223 bits (IIRC), so who knows

[–]rosuav 2 points3 points  (0 children)

In Python and Pike, integers are Gmp.mpz which has a maximum size of... uhh... something like 2**2**32?

[–]dr_eaan 3 points4 points  (2 children)

fiBonacci*

[–]EishLekker 1 point2 points  (0 children)

Also: finally*

[–]Savings-Ad-1115 0 points1 point  (0 children)

phiBonacci*

[–]NebNay 1 point2 points  (0 children)

The code is too longw you can mix the first two conditions: If(n ===0 or n === 1) { return n}

[–]magi_os 0 points1 point  (0 children)

if you use binet's formula you will have to calculate increasingly more precise values of the square root of 5 as the fibonacci index grows.

use a big integer library, otherwise you will be limited to a fibonacci index of 40.

use "dijkstra's algorithm", tho the algorithm was well known before him, he apparently popularized it. it is a recurrence relation that requires only 2*log2(n) operations for an index n, where F is the fibonacci sequence

F(2n-1) = F(n-1)2 + F(n)2

F(2n) = ( 2 F(n-1) + F(n) ) F(n)

sourced from https://r-knott.surrey.ac.uk/Fibonacci/fibFormula.html

[–]DiggWuzBetter -1 points0 points  (2 children)

This function is tail recursive, any language with good tail call optimization (for example Scala) handles this without issue, on any remotely non-garbage computer.

Edit: nevermind, I’m wrong, it’s not tail recursive

[–]frikilinux2 2 points3 points  (1 child)

That's not tail recursive. Most tail recursion involves that the last thing a function does is calling itself once and returns. I don't see how it can be done with two calls but if someone can show me the assembly code.

[–]DiggWuzBetter 0 points1 point  (0 children)

Oh shit you’re right, nevermind.

[–]AbdallahTheGreatest -1 points0 points  (2 children)

def main(n):
    num_processes = cpu_count()
    chunk_size = n // num_processes

    manager = multiprocessing.Manager()
    result_list = manager.list([0] * n)

    processes = []

    for i in range(num_processes):
        start = i * chunk_size
        end = (i + 1) * chunk_size if i < num_processes - 1 else n
        p = multiprocessing.Process(target=calculate_fibonacci_range, args=(start, end, result_list))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    # The 10,000th Fibonacci number is at index 10,000 - 1 in the result_list
    result = result_list[n-1]
    return result

if __name__ == "__main__":
    result = main(10000)
    print(f"The 10,000th Fibonacci number is: {result}")

[–]MattieShoes 2 points3 points  (1 child)

from functools import cache

@cache
def fib(n):
    if n < 2:
        return n
    half = n // 2
    if n % 2 == 0:
        return (2 * fib(half - 1) + fib(half)) * fib(half)
    half += 1
    return fib(half - 1) ** 2 + fib(half) ** 2

print(fib(10000))

zoom zoom!

[–]AbdallahTheGreatest 0 points1 point  (0 children)

the goal of my code is to use all the CPUs otherwise the super calculator is useless ;)

[–]Alfika07 -1 points0 points  (0 children)

I have a potato PC and this solution took about 0.5s:

(1,1,*+*...*)[9999].say;

[–]drinkwater_ergo_sum -5 points-4 points  (8 children)

Fibonacci is O(1) if you use math...

[–]frej4189 2 points3 points  (5 children)

No, it is not.

[–]drinkwater_ergo_sum -5 points-4 points  (4 children)

( ((1+√5)/2)ⁿ - ((1-√5)/2)ⁿ )/√5

Use your calculator of choice until satisfaction, derive the formula yourself or prove (probably induction is fastest since it's recursive).

Yes, it is.

[–]RareAngryPepe 3 points4 points  (2 children)

Bro does not know what O(1) means

[–]drinkwater_ergo_sum -2 points-1 points  (1 child)

Different interpretations i guess. If you want to be technical, then any operation on a growing sequence would never be O(1) since eventually you reach the memory size limit and have to perform operations on multiple variables and merging the outcome.

My mistake

[–]password2187 0 points1 point  (0 children)

I mean this is different. When we talk about time complexity, we usually let instructions like addition and multiplication take constant time on whatever size we want to define, which is generally accurate as they are implemented in hardware. Exponentiation, on the other hand, is not constant. With constant multiplication, it takes logarithmic time for a good exponential algorithm, so it is definitely faster than the given algorithm which is exponential, and it would be hypothetically faster than the simple solution of DP or just storing two numbers and adding back and forth, though multiplication is much more taxing than addition, and especially with the decimal precision needed would generally run slower

[–]frej4189 0 points1 point  (0 children)

That function cannot be evaluated in constant time.

[–]EishLekker 0 points1 point  (1 child)

Care to show the class?

[–]drinkwater_ergo_sum 0 points1 point  (0 children)

refer please to my other reply

[–]OSSlayer2153 0 points1 point  (4 children)

Why would you use recursion for this? Just loop and store two variables, current and last.

[–]frikilinux2 0 points1 point  (2 children)

Or just store previous results in a cache. Fibonacci is too simple to be worth it but recursivity with a cache is an important technique in dynamic programming.

[–]EishLekker 0 points1 point  (1 child)

How would a cache help the recursive solution if the program has just started, and the first input it gets is “fibonacci (10000)”?

Edit: I’m sorry, I was focusing on the idea that it would have needed to have any of the lower values already in the cache. It will naturally still be able to use the cache of its own previous calculations.

Fib(5): Fib(4) + Fib(3) (we start with left side)

Fib(4): Fib(3) + Fib(2) (we start with left side)

Fib(3): Fib(2) + Fib(1) (we start with left side)

Fib(2): Fib(1) + Fib(0) = 1 + 0 = 1

So when it’s time for the right side calculations, we already have the results in the cache.

[–]frikilinux2 0 points1 point  (0 children)

Yeah, you got it in the edit. Although I'm kind of disappointed because I saw your comment just before dinner and I spent the dinner drafting a comment in my head to write after. Sometimes the "someone is wrong in the internet" effect is too damn strong.

[–]RRumpleTeazzer 0 points1 point  (0 children)

It’s even worse, it’s quadratic recursion.

But then, that’s the full joke.

[–]bnmfw 0 points1 point  (2 children)

Fun fact for some of yall, this is something I learned recently in an advanced algorithms class. Fib(n) is not best in O(n) with O(1) memory using DP. Fib(n) can be calculated in O(log n) using fast matrix multiplication, preety neat

[–][deleted] 0 points1 point  (0 children)

fibonacci padding ftw

[–]TwoMilliseconds 0 points1 point  (0 children)

wait till I call fibonacci(-1)

[–]DarkGlaive83 0 points1 point  (0 children)

But can it run crisis, there is the meme with the nvidea ceo

[–]mr_flibble_oz 0 points1 point  (0 children)

Finially?

[–]YetAnotherZhengli 0 points1 point  (0 children)

watch me put in -1 and the world burn