short a_field[100],b_field[100];

struct MathBase *MathBase;	/* für floatRoutinen-Aufruf */
void *OpenLibrary();

main()
{
short flag;
register short i,j;
register short *a,*b;

    MathBase=(struct MathBase *)OpenLibrary("mathffp.library",0L);
                             /* ^^^^ für float-direkt-Aufruf (ggf. ist eine
                                Sicherheitsabfrage wohl angebracht) */
    flag=0;
    if(flag!=0)              /* hier wird noch kein bcc umgebogen */
    {
        for(i=49;i>=0;i--)   /* Wenn Startwert Konstante, Bedingung '>=0' und
                                i=Registervar, dann wird for in DBRA umgewan. */
        { 
            a_field[i]=i;    /* hier werden Arrayzuweisungen gekürzt und außerdem */
            a_field[i+50]=i; /* wird hier eine unnötige Registerzuweisung gelöscht */
        }

        i=67;
        a=a_field;b=b_field+i;

        j=i;                /* Wenn der Startwert keine Konstante ist, kann for
                               nicht in DBRA umgewandelt werden; do-while schon */
        do
        {
            *(a++)=*(--b);  /* hier gibts eine Prede- und eine Postinkrement
                               Addressierung */
            j--;
        }
        while(j>=0);
        
        j=i*40;             /* Dieses Mul wird in ASL und ADD umgewandelt. */
                            /* Das passiert auch, wenn man gar nicht dran denkt,
                               z.B. beim Errechnen eines Array-Offsets */
        i=j/32;             /* und dieses Div wird zu LSR (wenn j unsigned wäre,
                               zu ASR) */
    }
    
    Delay(50L);             /* hier wird ein indirekter Library-Aufruf in
                               einen direkten umgewandelt */;
    Forbid();               /* hier ebenfalls, nur daß wir uns diesmal das */
    Permit();               /* 'move.l _SysBase,a6' sparen */

    i=(short)( ((float)j) * 34.66 );
                            /* besonder schön ist das Umwandeln von indirekt
                               in direkt bei float-Rechenroutinen */
    switch(i)
    {
        case 3:
	    j=2;
            break;
        case 6:
            j=5;
            break;
        default:
            break;          /* hier wird ein BRA gelösch */

        /* Hier im switch-Verteilerblock wird ein bcc umgebogen */
    }
    CloseLibrary(MathBase);
}