{------------------------------------------------------------------------------
 - Subiect:
  Motanul felix îşi doarme somnul de prânz pe masa de lucru a Mihaelei, care
  tocmai rezolva probleme de matematică. Cuprins parcă de armonia şi frumuseţea
  numerelor, Felix visează că în jurul lui stau în cerc n şoricei, unul alb şi
  restul gri. Şoriceii sunt numerotaţi de la 1 la n. Motanul aude cum un glas
  cunoscut îi şopteşte la ureche:
  „Felix, tu trebuie să mănânci fiecare al  k-lea şoricel! Vei începe să numeri
  de la şoricelul x în sensul acelor de ceasornic. Al k-lea şoricel îl mănânci,
  apoi continui numărătoarea de la şoricelul care urmează celui mâncat!
  Dar... ai grijă! Şoricelul alb trebuie să rămână ultimul!”

 - Cerinta:
  Scrieţi un program care să îl ajute pe Felix să determine numărul x al
  şoricelului iniţial astfel încât, mâncând fiecare al k-lea şoricel, să rămână
  la sfârşit numai şoricelul alb.

 - Intrare:
  Fişierul de intrare cat.in conţine o singură linie pe care se află 3 numere
  naturale n, k, şi a separate prin câte un spaţiu, reprezentând, în ordine,
  numărul total de şoricei, al câtelea şoricel se elimină şi respectiv numărul
  de ordine al şoricelului alb.

 - Iesire:
  Fişierul de ieşire cat.out va conţine o singură linie pe care va fi scris un
  număr natural reprezentând cel mai mic număr de ordine al unui şoricel cu
  care se poate începe numărătoarea, astfel încât în final să rămână numai
  şoricelul alb.

  Observatie:
  Numarul x este univoc determinat, de aceea conditia ca el sa fie cel mai mic
  este de prisos.

 - Restrictii:
    3 <= n <= 600
    1 <= k <= 2*n
    1 <= a <= n

 - Exemplu:
    Intrare: n = 10,  k = 3,  a = 2
    Iesire:  x = 9

 - Metodele utilizate:
  Voi utiliza 2 metode simetrice din mai multe punctele de vedere:
  I  - cauta raspunsul, porneste de la n soricei, e inceata
  II - deduce raspunsul, porneste de la 1 soarece, e rapida
  Antonime:
        I   II
  mananka | skuipa
        + | -
       -1 | +1
      dec | inc
   repeat | while
        = | <>
        0 | n
 ------------------------------------------------------------------------------}
Program Cat ;
Uses CRT ;
Const
   fin_n  = 'cat.in'  ;
   fout_n = 'cat.out' ;
Var
   fin, fout : text ;
   x, n, k, a: word ;
   y, m: word ; {Omologii lui x si n in calcule}

{ x - nr soricelului cu care incepe numaratoarea
  k - cati soareci sa numar
  n - cati soareci sunt
  ex: n = 5, k = 4, x = 3 -> (3 4 5 1) x = 1 }
function cerc(k: integer ; n: word): word ;
begin { Aplica k pe intervalul 0..n-1 }
  cerc := (k mod n + n) mod n ;
end ;

{Pentru I metoda}
procedure mananka(var x, n: word) ;
begin
  x := cerc(x + k - 1, n) ; {soricelul care trebuieste mancat}
  dec(n) ;                  {Felix a mancat soricelul x}
end ;

{Pentru II metoda}
procedure skuipa(var x, n: word) ;
begin {Pur si simplu functia inversa a functiei mananka}
  inc(n) ;
  x := cerc(x - k, n) + 1 ;
end ;

{$I-}
BEGIN
  assign(fin,  fin_n) ;
  assign(fout, fout_n) ;
  reset(fin) ;
  if(IOResult = 0) then readln(fin, n,k,a)
  else begin  { Nu exista fisierul fin_n }
    writeln('Restrictii: 1<=n<=65535, 1<=k<=65535, 1<=a<=n') ;
    writeln(#10'Introduceti n, k si a: ') ; readln(n, k, a) ;
    rewrite(fin) ;
    writeln(fin, n:6,k:6,a:6,#10,'n':6,'k':6,'a':6) ;
  end ;
  close(fin) ;

  { Admitem ca pozitia n este una si aceeasi cu pozitia 0,
    iar soricelul alb se afla pe pozitia 0 (=n) }

{ I metoda: Cautam soricelul de la care se incepe numaratoarea }
  for x := 1 to n do begin            {Cautam soricelul cu care sa incepem}
    m := n ;
    y := x ;
    repeat mananka(y, m) until y = 0 ; {Mananka soriceii pana ajungi la cel alb}
    if m = 0 then break ;             {Soricelul alb a fost mankat ultimul}
  end ;
  { Deplasam soriceii pe cerc ca cel alb sa vina in pozitia a }
  { si transformam numerotarea din 0..n-1 in 1..n }
  x := cerc(x + a - 1, n) + 1 ;


{ II metoda: Admitem ca a ramas doar soricelul alb si Felix
             scuipa inapoi soriceii mancati }
  m := 1 ;
  y := 1 ;
  while m <> n do skuipa(y, m) ;  {Skuipa soriceii pana sunt n soricei}
  y := cerc(y + a - 1, n) + 1 ;

  clrscr ;  writeln('I - ',x,',   II - ',y) ;  readkey ; {x terbuie sa fie egal cu y}
  rewrite(fout) ;  writeln(fout, x) ;  close(fout) ;
END.