Amicable numbers

/*
    This program (ANSI C) computes the amicable numbers
    (therefore "an.c") within a given range. The method used by
    this program is rather simplistic. Last change, including minor
    improvements and conversion into ANSI C: Sept. 10th, 2023.
    Compile:    gcc -ansi -pedantic -O3 -o an an.c
    Invoke:     an [lower_limit] upper_limit
    Copyright (C) <March 19th, 2015> Henning POLZER.
    Send comment and error reports to: h underscore polzer at gmx dot de

    Example:
    an 1 10000  # "an 10000" yields the same (lower_limit==1 by default)

     220;        284
    1184;       1210
    2620;       2924
    5020;       5564
    6232;       6368

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

                    /* Erforderlich fuer: */
#include <math.h>   /* floor () */
#include <stdio.h>  /* printf () */
#include <stdlib.h> /* atoi () */

typedef long ganz;  /* signed! */
typedef struct {
            ganz erster,zweiter;
    } freunde; /* speichert Zahlwerte des Freundepaares */

/*
    Gibt die TeilerSumme einer gegebenen Zahl zurueck.
*/
ganz ts(ganz z)
{
    ganz i=2,gegenteiler,schleife=z,summe=1;

    do {
      gegenteiler=floor(schleife/i);
      if (schleife%i==0)
        /* Teiler=Gegenteiler? Nur Teiler beachten: */
        (i==gegenteiler)?summe++:(summe+=gegenteiler+i);
      i++;
    } while (gegenteiler>=i);
    return summe;
} /* ts */

/*
    Prueft, ob zu der uebergebenen Zahl z eine befreundete
    Zahl existiert und liefert in diesem Falle das Paar
    befreundeter Zahlen zurueck. Andernfalls liefert
    die Funktion die gepruefte Zahl und die Teilersumme
    derselben als negative Zahlen zurueck, fuer den Fall,
    dass diese weiter betrachtet werden sollen. (-1 als
    Rueckgabewert von f.zweiter steht fuer eine
    Primzahl, wenn z>1.)
*/
freunde auf_freundschaft_pruefen(ganz z)
{
    ganz hilf,j=z,startwert=z;
    freunde f;

    /* Berechnungen nur fuer Zahlen>3: */
    (j<3)?j=3:0;

    hilf=ts(j);
    if((ts(hilf)==j)&&(hilf>j)) {
      f.erster=j; /* Paar gefunden */
      f.zweiter=hilf;
    } else {
        f.erster=startwert*-1; /* Kein Paar */
        f.zweiter=hilf*-1;
      } /* else */

    return f;
} /* auf_freundschaft_pruefen */

int main(int argc,char *argv[])
{
    ganz i,ug=1,og=1;
    freunde f;

    if(argc==2) og=atoi(argv[1]);
    if(argc==3) {
      ug=atoi(argv[1]);
      og=atoi(argv[2]);
    } /* if(argc==3) */

    for(i=ug;i<=og;i++) {
      f=auf_freundschaft_pruefen(i);
      /*
         Wenn mindestens ein Rueckgabewert positiv ist, hat
         das Programm ein Paar befreundeter Zahlen gefunden:
      */
      if(f.erster>0) printf("%15.ld;%15.ld\n",f.erster,f.zweiter);
      /* Kommentarmarkierungen folgender Zeile entfernen, um Primzahlen auszugeben: */
      /*if((f.zweiter==-1)&&(i>1)) printf("%15.ld: Primzahl\n",i);*/
    } /* for(i=ug;i<=og;i++) */

    return 0;
} /* main */