* Далее - поиск внутрилежащих (не первой и не последней) дырок. Вообще, дырку найти практически невозможно за короткое время. Например, представь:
        * 100 тыс номеров, причем известно, что есть дырки в <1 тыс номеров где-нибудь посередке, их несколько
        * Значит надо сделать > 100тыс/1тыс=100 проверок, - долго, а дырки нужно найти и на порядок меньшие...
                
        * Автокорреляция последовательности занятых номеров! Сначала выберем ВСЕ использованные номера в курсор, но не просто номера, а:
        *   ...номер-4, номер-3, номер-2, номер-1 (-0 - НЕ НАДО!)  Обьединим эти выборки UNION [DISTINCT] в "курсор"
        *   далее: SELECT номер WHERE номер NOT IN (SELECT * FROM "курсор") - вся фишка в "NOT" - значит антикорреляция
        *   смягчить реакцию на одиночные "всплески" номеров можно добавлением в UNION-курсор нескольких значений: номер+1, номер+2...
        *   этим самым получим особые точки - ГРАНИЦЫ перехода из блока (серия использованных номеров) в дырку (прогал в использованных номерах) !
        * Хорошо работает, если номера заняты кучно - получается небольшые массивы особых точек (например, после кампани1 печати серийно нумерованых договоров)
        * Плохо получается, если номера заняты шумоподобно - массив особых точек большой (реально заключенные договора по заранее нумерованным и напечатанным)...
                
        * Вобщем, вышеописанное - это "цифровой фильтр" с линиями задержки (ЛЗ) и на выходе с сумматором (здесь OR/AND-оператор) с весовыми коэфф. от каждого:
        * Пусть, во всей выборке номеров (ВсНо), мы хотим отловить сигнал "ступенька вниз", т.е. такие места в ВсНо, где наблюдается последовательность:
        *   - непрерывная последовательность N присутствующих номеров (ПрНо)
        *   - затем непрерывная последовательность M отсутствующих номеров (ОтНо)
        *   - в результате мы хотим получить TRUE на выходе фильтра в особой точке - граничном номере (ГН), ПОСЛЕДНИМ ПрНо ПЕРЕД НАЧАЛОМ ОтНо
        * Чтобы получить TRUE (отфильтровать) ТОЛЬКО ГН "ступенька вниз", можно построить логическое произведение,
        * состоящее из N+M рядом лежащих с ГН номеров, которые мы их "видим" в одной "временной" точке - ГН - при помощи отводов от ЛЗ:
        *   - ПрНо: наличия сигналов (номеров) на N отводах ЛЗ, причем отводов, превращающих мЕньшие номера в бОльшие (номер+1, номер+2...),
        *   - ОтНо: факт отсутствия сигналов (номеров) на M отводах ЛЗ, превращающих бОльшие номера в мЕньшие (номер-1, номер-2...).
        * Представим последовательность номеров на оси абсцисс, (горизонтальная ось, где откладывается номер, 
        * Представим задержку в ЛЗ как перемещение на линии абсцисс, (горизонтальная ось, где откладывается номер,
        * по оси ординат, соответственно, только 1/0 - наличие/отсутствие этого номера). Тогда операция "задержка" выражается как операция суммирования:
        *    номер+1, или номер-1 и т.п.
        * Эти элементарные операции - задержка (и булевы операции) - можно выполнять в WHERE:
        *    SELECT WHERE номер [NOT] IN (SELECT номер-1...)
        * а значит для ВСЕХ ПрНо ОДНОВРЕМЕННО, в одной команде SELECT!Итак:
        RELEASE B  && в этот массив соберем и вернем особые точки, ГН
        LOCAL m.ВсНо, m.ПрНо, m.ОтНо  && это курсор всех исходных занятых номеров (ВсНо), курсоры ПрНо и ОтНо (внимание! буквы в именах - русские)

        m.д = Самовызов("дырка")       && дырка д.б. больше этого размера (мин. размер низины "ступени вниз")
        m.б = Самовызов("блок")        && макс. расстояние от ГН до ближайшего номера вверх, чтобы считать их оба одной серией номеров
        m.з = Самовызов("заполнение")  && мин. заполнение вершины "ступени вниз", в процентах (%), чтобы отсеять слабозаполненные серии номеров
        m.п = Самовызов("переход")     && минимальный  размер НЕПРЕРЫВНОЙ серии ПрНо (вкл. сам ГН) перед переходом вершины в низину "ступени вниз"
        m.u = Самовызов("UNION")       && ограничение на кол. UNION-операторов в VFP (в VFP - вроде не лимитировано, но: длина строки, время выполнения, все такое...)

        m.ВсНо = SYS(2015)
        SELECT 0
        SELECT номер INTO CURSOR (m.ВсНо) READWRITE NOCONSOLE
        INDEX ON номер TAG номер  && последующим SELECTам этот индекс не сильно нужен, похоже, они их сами на-лету создают, если им надо

           * Далее делаем UNION-SELECTы из ВсНо, которые сразу и DISTINCT-обьединяют, т.к.
           * Учти, количество UNION пропорционально увеличивает время выполнения (на каждую добавляемую запись идет поиск на существование номера,
           * в нашем случае размер курсора на 1м же UNION примерно стабилизируется, поэтому - пропорционально...)
           * Практика показывает, что СОЗДАНИЕ этих UNION-курсоров и занимает основное время всего алгоритма, хотя и выполняется в локальном курсоре...
           * Собственно в этих выборках и происходит "низкочастотная фильтрация" (ЛЗ,UNION) последовательности входных номеров

           m.s = ""  && макрострока UNION-SELECTов для ПрНо-фильтра: номер IN (эта выборка) - это будет часть фильтра ПрНо
           * создаем макростроку ПрНо: UNION-набор SELECTов с выбираемыми значениями с N отводов для поиска ПрНо {номер+1, номер+2, номер+3...номер+N}
           FOR m.i=1 TO MIN(m.б, m.u)  && создаем макростроку ПрНо - UNION-набор SELECTов
               m.s = SRAZDS(m.s, " UNION ", "SELECT номер+"+TRANSFORM(m.i)+" FROM "+m.ВсНо)
           ENDFOR  && создавали макростроку ПрНо - UNION-набор SELECTов
                   
           SELECT 0  && выполняем макростроку - выбираем ПрНо-курсор
           m.ПрНо = SYS(2015)
           &s INTO CURSOR (m.ПрНо) NOCONSOLE

           m.s = ""  && макрострока UNION-SELECTов для ОтНо-фильтра: номер NOT IN (эта выборка) - это будет часть фильтра ОтНо
           * создаем макростроку ОтНо: UNION-набор SELECTов с выбираемыми значениями с M отводов для поиска ОтНо {номер-1, номер-2, номер-3...номер-M}
           FOR m.i=1 TO MIN(m.д, m.u)  && создаем макростроку ОтНо - UNION-набор SELECTов
               m.s = SRAZDS(m.s, " UNION ", "SELECT номер-"+TRANSFORM(m.i)+" FROM "+m.ВсНо)
           ENDFOR  && создавали макростроку ОтНо - UNION-набор SELECTов
                   
           SELECT 0  && выполняем макростроку - выбираем ОтНо-курсор
           m.ОтНо = SYS(2015)
           &s INTO CURSOR (m.ОтНо) NOCONSOLE

           m.s = ""  && макрострока AND-фильтра IN-SELECTов для ПрНо, которые должны НЕПРЕРЫВНО прилегать к ГН слева (чтобы отсеять одиночные и небольшие всплески...)
           * создаем макростроку ОтНо: AND-набор SELECTов с выбираемыми значениями с M отводов для поиска ОтНо {номер+1, номер+2, номер+3...}
           FOR m.i=1 TO MIN(m.п-1, m.u)  && создаем макростроку ПрНо - AND-набор SELECTов
               m.s = m.s + " AND " + " номер IN (SELECT номер+"+TRANSFORM(m.i)+" FROM "+m.ВсНо+")"
           ENDFOR  && создавали макростроку ПрНо - AND-набор SELECTов
                   
           * Собственно Автокорреляция (основной выборки номеров ВсНо с ПрНо-курсором и ОтНо-курсором), сумматор отводов с ЛЗ с нужными весовыми коэфф.
           * Получаем массив особых точек, ГН, из ВсНо
           * Свойства этой выборки, вернее, свойства полученных ГН:
           *   - гарантировано присутствуют в исходном списке (т.е. точно существующие номера)
           *   - гарантировано после них присутствует "прогал" в номерах, длиной в кол. UNION-операторов в m.ОтНо
           *   - гарантировано имеют до себя хотя бы 1 номер на длине в кол. UNION-операторов в m.ПрНо... как бы сделать счетчик номеров в "вершине ступени"
           *   - на концах исследуемого диапазона (1..m.h) извлечение не произведено по естественным причинам (не достаточно данных для определения ГН)
           *   - гарантирована НЕПРЕРЫВНАЯ последовательность ПрНо перед ГН, которая есть количество фильтров "номер IN (SELECT номер+1,2,3..."
           RELEASE G
           SELECT * FROM (m.ВсНо);  && при любом фильтре исходным набором являются ФИЗИЧЕСКИ присутствующие номера
                  WHERE BETWEEN(номер, m.l+m.б+1, m.h-m.д-1)  AND;  && это просто фильтр на границы возвращаемых номеров (не анализируем края диапазона номеров)
                        номер NOT IN (SELECT * FROM (m.ОтНо)) AND;   && фильтр на ОТСУТСТВИЕ  ОтНо на низине  "ступеньки вниз"
                        номер     IN (SELECT * FROM (m.ПрНо));       && фильтр на ПРИСУТСТВИЕ ПрНо на вершине "ступеньки вниз"
                        &s;                                          && в точке ГН обязательна НЕПРЕРЫВНАЯ последовательность вот стольких ПрНо
                  INTO ARRAY G;
                  ORDER BY 1;  && мЕньшие номера - в начало массива
                  NOCONSOLE

           IF _TALLY>0
              * =massedit(@G, 1, m.a)
              DIMENSION G[ALEN(G)]  && ранее это был 2-массив [k,1], превратим его в 1-массив
              =ASORT(G)

              * Удалим некоторые найденные ГН, "ступени вниз", не полностью соответствующие условиям (т.к. мы нашли немного лишних)
              SELECT (m.ВсНо)
              FOR m.i=1 TO ALEN(G)  && анализатор найденных ГН
                  m.x = G[m.i]  && очередная ГН
                  COUNT FOR BETWEEN(номер, m.x-m.б+1, m.x+0) TO m.n  && число ПрНо в вершине "ступени вниз" (д.б. в меру заполнено)
                  COUNT FOR BETWEEN(номер, m.x+1, m.x+m.д-1) TO m.m  && число ПрНо в низине  "ступени вниз" (д.б. =0)
                  IF m.n<m.б*(m.з/100) .OR.;  && плохо заполнена вершина "ступени вниз"
                     m.m>0                    && в низине "ступени вниз" есть ПрНо
                     LOOP
                  ENDIF
                  * заполняем выходной 2-массив [ГН, длина_дырки], вернуть количество его строк
                  LOCATE FOR номер=m.x  && не проверяем на FOUND, т.к. однозначно это есть "ступень вниз"...
                  SKIP  && измеряем длину дырки (ищем следующий занятый номер). Тоже не проверяем на нахождение, т.к. это д.б. "внутренняя" дырка...
                  m.r = m.r+1
                  DIMENSION parDOP1[m.r,3]
                  parDOP1[m.r,1] = m.x
                  parDOP1[m.r,2] = номер-m.x-1
              ENDFOR  && анализатор найденных ГН
              =ASORT(parDOP1,1)  && окончательная сортировка
           ENDIF  && выборка номеров не пуста
           RELEASE G

           DO CLOSER WITH m.ВсНо, m.ПрНо, m.ОтНо