Последовательность Хемминга образуют натуральные числа не имеющие других простых делителей, кроме 2,3,5. найти первые n

type
  // содержит или данные, или 2 ветки
  SortedTree<T> = sealed class where T: IComparable<T>;
    l,r: SortedTree<T>; // l <= r
    data: T;
    l_min,l_max, r_min,r_max: T;
    
    constructor(data: T);
    begin
      self.data := data;
      self.l_min := data;
      self.r_max := data;
    end;
    
    procedure UpdateL(node: SortedTree<T>);
    begin
      self.l := node;
      if node=nil then exit;
      self.l_min := node.l_min;
      self.l_max := node.r_max;
    end;
    
    procedure UpdateR(node: SortedTree<T>);
    begin
      self.r := node;
      if node=nil then exit;
      self.r_min := node.l_min;
      self.r_max := node.r_max;
    end;
    
    constructor(l,r: SortedTree<T>);
    begin
      UpdateL(l);
      UpdateR(r);
    end;
    
//    function IsDataNode := (l=nil) and (r=nil);
    function IsDataNode := r=nil; // для данной задачи должно быть достаточно
    /// Deq на ноде, у которой IsDataNode=true - не ожидается
    function Deq: T;
    begin
      if l.IsDataNode then
      begin
        Result := l.data;
        self.data := r.data;
        self.UpdateL( r.l );
        self.UpdateR( r.r );
      end else
        Result := l.Deq;
    end;
    
    function Minimize: SortedTree<T>;
    begin
      Result := (l<>nil) or (r=nil) ? self : r;
      Result.l := Result.l?.Minimize;
      Result.r := Result.r?.Minimize;
    end;
    
    function Enq(el: T): SortedTree<T>;
    begin
      if not self.IsDataNode then
      begin
        Result := self;
        // предпочтение левой ветке, чтоб немного уменьшить скорость создания новых нод
        //(удаление всегда начинается слева, поэтому Minimize постоянно убивает текущую ноду, а enq сразу создаёт новые в правой, поэтому неравномерно)
        if el.CompareTo(self.r_min)<0 then
          Result.UpdateL( l.Enq(el) ) else
          Result.UpdateR( r.Enq(el) );
      end else
      begin
        var comp := self.data.CompareTo(el);
        Result :=
        comp=0 ?
          self : // потому что 2*3 и 3*2
        comp<0 ?
          new SortedTree<T>(
            self, new SortedTree<T>(el)
          ) :
          new SortedTree<T>(
            new SortedTree<T>(el), self
          );
      end;
    end;
    
    procedure Println(tabs: integer := 0);
    begin
      if IsDataNode then
        Writeln($'{#9*tabs}Node[{self.data}]') else
      begin
        Writeln($'{#9*tabs}Range[{l_min}..{r_max}]');
        l.Println(tabs+1);
        r.Println(tabs+1);
      end;
    end;
    
  end;
  
function hem: sequence of BigInteger;
begin
  yield 1; // не гуглил, это тут надо?
  
  // работает и с <integer>, но тогда n очень ограничено
  var prev := new SortedTree<BigInteger>(2);
  prev := prev.enq(3);
  prev := prev.enq(5);
  
  while true do
  begin
    // дебаг. а ещё красиво
//    prev.Println;
//    Writeln('='*50);
//    Readln;
    
    var val := prev.Deq;
    prev := prev.Minimize;
    yield val;
    
    prev := prev.Enq(val*2);
    prev := prev.Enq(val*3);
    prev := prev.Enq(val*5);
    
  end;
  
end;
 
begin
  hem.Skip(10000).Take(30)
//  .ForEach(el->begin end);
  .PrintLines;
end.

    procedure Println(tabs: integer := 0) :=
    if IsDataNode then
      Writeln($'{#9*tabs}Node[{self.data}]') else
    begin
      Writeln($'{#9*tabs}Range[{l_min}..{r_max}]');
      l.Println(tabs+1);
      r.Println(tabs+1);
    end;