MODULE Nondeterminate;

  IMPORT
    con := Console,
    Random;

  CONST
    MAX_NUM = 10;

  VAR
    permutation: ARRAY MAX_NUM OF INTEGER;

  PROCEDURE RandomPermutation(n: INTEGER);
  VAR
    i: INTEGER;
    j: INTEGER;
    rnd: INTEGER;
    choosen: ARRAY MAX_NUM OF BOOLEAN;
  BEGIN
    FOR i := 0 TO n - 1 DO
      choosen[j] := FALSE;
    END;
    FOR i := n TO 1 BY -1 DO
      IF i # 1 THEN       
        rnd := Random.Random() MOD i;
      ELSE
        rnd := 0;
      END;
      j := 0;
      WHILE choosen[j] OR (rnd # 0) DO
        IF ~choosen[j] THEN
          rnd := rnd - 1;
        END;
        j := j + 1;
      END;
      choosen[j] := TRUE;
      permutation[n - i] := j;
    END;
  END RandomPermutation;

  PROCEDURE PrintPermutation(n: INTEGER);
  VAR
    i: INTEGER;
  BEGIN
    FOR i := 0 TO n - 1 DO
      con.Int(permutation[i]); con.Str(" ");
    END;
    con.Ln;
  END PrintPermutation;

  PROCEDURE Test1(n: INTEGER);
  BEGIN
    WHILE n MOD 2 = 0 DO
      con.Int(2); con.Str(" ");
      n := n DIV 2;
    ELSIF n MOD 3 = 0 DO
      con.Int(3); con.Str(" ");
      n := n DIV 3;
    ELSIF n MOD 5 = 0 DO
      con.Int(5); con.Str(" ");
      n := n DIV 5;
    END;
    con.Ln;
  END Test1; 
 
  PROCEDURE Test2(n: INTEGER);
  VAR
    step: INTEGER;
    continue: BOOLEAN;
  BEGIN
    continue := TRUE;
    WHILE continue DO
      RandomPermutation(3);
      continue := FALSE;
      step := 0;
      WHILE (step < 3) & ~continue DO
        continue := TRUE;
        IF (permutation[step] = 0) & (n MOD 2 = 0) THEN
          con.Int(2); con.Str(" ");
          n := n DIV 2;
        ELSIF (permutation[step] = 1) & (n MOD 3 = 0) THEN
          con.Int(3); con.Str(" ");
          n := n DIV 3;
        ELSIF (permutation[step] = 2) & (n MOD 5 = 0) THEN
          con.Int(5); con.Str(" ");
          n := n DIV 5;
        ELSE
          continue := FALSE;
          step := step + 1;
        END;
      END;
    END;
    con.Ln;
  END Test2;

BEGIN
  Random.Randomize();
  Test1(466560000);
  Test2(466560000);
END Nondeterminate.

  Branches = RECORD
    b: ARRAY MAX_NUM OF INTEGER;
    i, j: INTEGER
  END;
 
  PROCEDURE Init(VAR b: Branches);
  BEGIN
    b.i := 0;
    b.j := 0
  END Init;
 
  PROCEDURE Put(VAR b: Branches; case: INTEGER; cond: BOOLEAN): INTEGER;
  BEGIN
    ASSERT(case = b.j);
    IF cond THEN
      b.b[b.i] := case;
      INC(b.i)
    END;
    INC(b.j);
    RETURN ORD(cond)
  END Put;
 
  PROCEDURE Rand(VAR b: Branches): INTEGER;
  VAR i: INTEGER;
  BEGIN
    i := Random.Random() MOD b.i;
    Init(b);
    RETURN i
  END Rand;
 
  PROCEDURE Test3(n: INTEGER);
  VAR branches: Branches;
  BEGIN
    Init(b);
   
    WHILE Put(branches, 0, n MOD 2 = 0)
        + Put(branches, 1, n MOD 3 = 0)
        + Put(branches, 2, n MOD 5 = 0) > 0
    DO
      CASE Rand(branches) OF
        0:
        con.Int(2); con.Str(" ");
        n := n DIV 2
      | 1:
        con.Int(3); con.Str(" ");
        n := n DIV 3
      | 2:
        con.Int(5); con.Str(" ");
        n := n DIV 5
      END
    END;
    con.Ln;
  END Test3;

  PROCEDURE Test3(n: INTEGER);
  VAR
    queue: ARRAY 3 OF INTEGER;
    i: INTEGER;
    t: INTEGER;
    PROCEDURE Condition(cond, n: INTEGER): BOOLEAN;
    VAR
      result: BOOLEAN;
    BEGIN
      CASE cond OF
        0: result := n MOD 2 = 0;
      | 1: result := n MOD 3 = 0;
      | 2: result := n MOD 5 = 0;
      END;
      RETURN result
    END Condition;
  BEGIN
    queue[0] := 0;
    queue[1] := 1;
    queue[2] := 2;
    i := 0;
    WHILE (i < 3) & ~Condition(queue[i], n) DO
      i := i + 1;
    END;
    WHILE i < 3 DO
      CASE queue[i] OF
        0: con.Int(2); con.Str(" ");
           n := n DIV 2;
      | 1: con.Int(3); con.Str(" ");
           n := n DIV 3;
      | 2: con.Int(5); con.Str(" ");
           n := n DIV 5;
      END;
      WHILE i < 2 DO
        t := queue[i];     
        queue[i] := queue[i+1];
        queue[i+1] := t;
        i := i + 1;
      END;
      i := 0;
      WHILE (i < 3) & ~Condition(queue[i], n) DO
        i := i + 1;
      END;
    END;
  END Test3;

MODULE Dijkstra;

  IMPORT
    Memory;

  TYPE
    Repetition* = POINTER TO RecordRepetition;
    ProcCondition* = PROCEDURE (obj: Repetition): BOOLEAN;
    ProcCommand* = PROCEDURE (obj: Repetition);
    GuardedCommand* = RECORD
      condition*: ProcCondition;
      command*: ProcCommand
    END;
    GuardedCommands = POINTER TO RECORD
      guardedCommand: GuardedCommand;
      next: GuardedCommands
    END;
    RecordRepetition* = RECORD
      head: GuardedCommands
    END;

  PROCEDURE Add*(repetition: Repetition; VAR gc: GuardedCommand);
  VAR
    node: GuardedCommands;
  BEGIN
    NEW(node);
    IF node # NIL THEN
      node.guardedCommand := gc;
      node.next := repetition.head;
      repetition.head := node;
    END;
  END Add;

  PROCEDURE Execute*(repetition: Repetition);
  VAR
    node: GuardedCommands;
    prev: GuardedCommands;
    last: GuardedCommands;
  BEGIN
    prev := NIL;
    node := repetition.head;
    (* Ищем первое условие, которое выполняется. *)
    WHILE (node # NIL) & ~node.guardedCommand.condition(repetition) DO
      prev := node;
      node := node.next;
    END;
    (* Если условие найдено, то выполняем команду. *)
    WHILE node # NIL DO
      (* Выполняем команду. *)
      node.guardedCommand.command(repetition);
      (* Переставляем команду в конец очереди.*)
      last := node;
      WHILE last.next # NIL DO
        last := last.next;
      END;
      IF node # last THEN
        IF prev # NIL THEN
          prev.next := node.next;
        ELSE
          repetition.head := node.next;
        END;
        last.next := node;
        node.next := NIL;
      END;
      prev := NIL;
      node := repetition.head;
      (* Ищем первое условие, которое выполняется. *)
      WHILE (node # NIL) & ~node.guardedCommand.condition(repetition) DO
        prev := node;
        node := node.next;
      END;
    END;
    (* Если ни одно из условий не выполняется, то цикл Дейкстры завершается. *)
  END Execute;

END Dijkstra.

MODULE Test;

  IMPORT
    Memory,
    Out,
    WinConsoleOut,
    Dijkstra;

  TYPE
    Repetition = POINTER TO RepetitionRecord;
    RepetitionRecord = RECORD (Dijkstra.RecordRepetition)
      n: INTEGER
    END;

  VAR
    writer: WinConsoleOut.Writer;

  PROCEDURE Condition1(obj: Dijkstra.Repetition): BOOLEAN;
  BEGIN
    RETURN obj(Repetition).n MOD 2 = 0
  END Condition1;

  PROCEDURE Command1(obj: Dijkstra.Repetition);
  BEGIN
    ASSERT(Out.Text(writer, "2 "));
    obj(Repetition).n := obj(Repetition).n DIV 2;
  END Command1;

  PROCEDURE Condition2(obj: Dijkstra.Repetition): BOOLEAN;
  BEGIN
    RETURN obj(Repetition).n MOD 3 = 0
  END Condition2;

  PROCEDURE Command2(obj: Dijkstra.Repetition);
  BEGIN
    ASSERT(Out.Text(writer, "3 "));
    obj(Repetition).n := obj(Repetition).n DIV 3;
  END Command2;

  PROCEDURE Condition3(obj: Dijkstra.Repetition): BOOLEAN;
  BEGIN
    RETURN obj(Repetition).n MOD 5 = 0
  END Condition3;

  PROCEDURE Command3(obj: Dijkstra.Repetition);
  BEGIN
    ASSERT(Out.Text(writer, "5 "));
    obj(Repetition).n := obj(Repetition).n DIV 5;
  END Command3;

  PROCEDURE Test;
  VAR
    gc: Dijkstra.GuardedCommand;
    repetition: Repetition; 
  BEGIN
    NEW(repetition);
    gc.condition := Condition1;
    gc.command := Command1;
    Dijkstra.Add(repetition, gc);
    gc.condition := Condition2;
    gc.command := Command2;
    Dijkstra.Add(repetition, gc);
    gc.condition := Condition3;
    gc.command := Command3;
    Dijkstra.Add(repetition, gc);
    repetition.n := 466560000;
    Dijkstra.Execute(repetition);
  END Test;

BEGIN
  ASSERT(WinConsoleOut.Create(writer) & writer.Open(writer));
  Test;
  ASSERT(writer.Close(writer));
END Test.