Crea un programa con un simple GOTO

Su tarea es construir el programa más grande posible que use exactamente un GOTO, sin el cual todo el programa (o al menos una gran parte de él) debe ser completamente reestructurado. El puntaje se cuenta como el número de declaraciones en su código que cambian de lugar o se introducen nuevamente (eliminar las declaraciones no se agrega a su puntaje) cuando el código se reestructura sin el GOTO (otros pueden desafiar su reestructuración presentando un elegante). Como se trata de bolos de código, gana la puntuación más alta.

Nota: No reclamo ninguna responsabilidad por los ataques de velociraptor al intentar este desafío.

C fizzbuzz

Esta solución se basa en la idea de interrupciones y variables de etiqueta (solo gcc, lo siento). El programa configura un temporizador que periódicamente llama a main, donde vamos a cualquier lugar donde la última ejecución de nuestro controlador de interrupciones (main) nos indique que deberíamos hacerlo.

Nunca he usado temporizadores o variables de etiqueta antes, así que creo que hay mucho para jugar aquí.

#include <sys/time.h>
#include <signal.h>
#include <stdio.h>

int main(int argc)
{
    static int run = 1;
    static int* gotoloc = &&init;
    static int num = 0;
    static int limit = 50;

    goto *gotoloc;
init:
    signal(SIGVTALRM, (void (*)(int)) main);
    gotoloc = &&loop;

    struct itimerval it_val;

    it_val.it_value.tv_sec = 0;
    it_val.it_value.tv_usec = 100000;
    it_val.it_interval.tv_sec = 0;
    it_val.it_interval.tv_usec = 100000;
    setitimer(ITIMER_VIRTUAL, &it_val, NULL);

    while(run);

loop:
    num = num + 1;
    run = num < limit;
    gotoloc = &&notfizz + (&&fizz - &&notfizz) * !(num % 3);
    return 1;

fizz:
    printf("fizz");
    gotoloc = &&notbuzz + (&&buzz - &&notbuzz) * !(num % 5);
    return 1;

notfizz:
    gotoloc = &&notfizzbuzz + (&&buzz - &&notfizzbuzz) * !(num % 5);
    return 1;

buzz:
    printf("buzz\n");
    gotoloc = &&loop;
    return 1;

notbuzz:
    printf("\n");
    gotoloc = &&loop;
    return 1;

notfizzbuzz:
    printf("%d\n", num);
    gotoloc = &&loop;
    return 1;
}

Perl

No soy muy bueno en los bolos, pero sospecho que esto puede interesar al OP. Este es un tamiz de Eratóstenes usando un goto variable. Si esto se 'refactorizara', dudo que algo sea reutilizable, aparte de las primeras líneas. Cuando finaliza el tamiz, todos los 1s restantes en la @primesmatriz corresponden a valores primos.

Para mayor diversión, no se usan ands, ors, ternaries, condicionales u operadores de comparación de ningún tipo.

@primes[2..1e4]=(1)x9999;
$a=2;
Y:
  $b=$a*~-$a;
X:
  $primes[$b+=$a+=$c=$a/100%2+$b/1e4%2]=0;
  goto"$c"^h;
Z:

do

Mi uso de macros quizás no lo convierte en "un GOTO".
Y es bastante corto, por lo que "completamente reestructurado" no es mucho.
Pero aquí está mi intento de todos modos.

Lee un número de la entrada estándar, lo imprime modulu 3.

int main() {
    char s[100], *p, r=0;
    void *pl[] = { &&a, &&b, &&c, &&d, &&e, &&f, &&g, &&h, &&i, &&j, &&a, &&b, &&x, &&y, &&z }, *p1;
    p = gets(s);
    #define N(n) (pl+n)[!*p*60+*p-48];p++;goto *p1
    a: p1=N(0);
    b: p1=N(1);
    c: p1=N(2);
    d: p1=N(0);
    e: p1=N(1);
    f: p1=N(2);
    g: p1=N(0);
    h: p1=N(1);
    i: p1=N(2);
    j: p1=N(0);
    z: r++;
    y: r++;
    x: printf("%d\n", r);

    return 0;
}