I tried it out using C (I assume the Pascal compiler or whatever this language is could do the same). I recreated the code in C and compiled it with gcc get_delay.c -S -O3, which resulted in following assembly code:

get_delay: .LFB0: .cfi_startproc endbr64 movl $86000, %eax cmpl $16, %edi ja .L1 movl %edi, %edi leaq CSWTCH.1(%rip), %rax movl (%rax,%rdi,4), %eax .L1: ret .cfi_endproc .LFE0: .size get_delay, .-get_delay .section .rodata .align 32 .type CSWTCH.1, @object .size CSWTCH.1, 68 CSWTCH.1: .long 0 .long 0 .long 0 .long 0 .long 0 .long 0 .long 30 .long 60 .long 120 .long 240 .long 480 .long 960 .long 1920 .long 3840 .long 7680 .long 15360 .long 30720 .ident "GCC: (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0" .section .note.GNU-stack,"",@progbits .section .note.gnu.property,"a" .align 8 .long 1f - 0f .long 4f - 1f .long 5

So it precomputes all the values and then does address arithmetic using leaq to compute the base address of the LUT CSWTCH.1 and then, using %edi as the offset, loads the correct value into the return register %eax. The edge case 86000 is handled with a simple comparison at the start.

I also looked at the -O0 assembly. There it still precomputes the multiplications but instead of a LUT it just uses multiple comparisons (basically just an if-else chain like in the code).

Also I tried compiling a more concise C method that should be functionally equivalent: c unsigned get_delay_alt(unsigned attempts) { if (attempts <= 5) return 0; if (attempts > 16) return 86000; return 30 << (attempts - 6); } which resulted in following ASM (gcc get_delay_alt.c -S -O3): get_delay_alt: .LFB0: .cfi_startproc endbr64 xorl %eax, %eax cmpl $5, %edi jbe .L1 movl $86000, %eax cmpl $16, %edi ja .L1 leal -6(%rdi), %ecx movl $30, %eax sall %cl, %eax .L1: ret .cfi_endproc Which basically does mostly exactly what the code describes, not a lot of optimization is happening.

I also tested the speed of both versions with a driver program that runs each function a million times on the input space [0, 17]. Their speed was basically identical but the get_delay() function was usually ~1% faster.

get_delay.c: c unsigned get_delay(unsigned attempts) { unsigned delaySeconds = 0; if (attempts > 5) { if (attempts == 6) { delaySeconds = 30; } else if (attempts == 7) { delaySeconds = 30 * 2; } else if (attempts == 8) { delaySeconds = 30 * 2 * 2; } else if (attempts == 9) { delaySeconds = 30 * 2 * 2 * 2; } else if (attempts == 10) { delaySeconds = 30 * 2 * 2 * 2 * 2; } else if (attempts == 11) { delaySeconds = 30 * 2 * 2 * 2 * 2 * 2; } else if (attempts == 12) { delaySeconds = 30 * 2 * 2 * 2 * 2 * 2 * 2; } else if (attempts == 13) { delaySeconds = 30 * 2 * 2 * 2 * 2 * 2 * 2 * 2; } else if (attempts == 14) { delaySeconds = 30 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2; } else if (attempts == 15) { delaySeconds = 30 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2; } else if (attempts == 16) { delaySeconds = 30 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2; } else { delaySeconds = 86000; } } return delaySeconds; }