Estava faltando descomplicar...

Vide exemplo de minha autoria que baixa um arquivo da internet... talvez ficar milionário!

Para trabalhar com as funções HB_UNZIPFILE e HB_ZIPFILE você precisa linkar as LIBs: hbzip.lib; hbmzip.lib; zlib.lib.

Estamos anexando o programa para download no rodapé.

FUNCTION MAIN()
*** definições iniciais ***-------------------------------------------------
SETMODE(60,132)
*** SETs
SET SCOREBOARD OFF
SET DATE BRITISH
SET(36, 23)
SET(37, .F.)
SET DELETED ON
SET EPOCH TO 1980
SETMODE(25,80)
SET MESSAGE TO 24
SET OPTIMIZE ON
SETMOUSE(.t.)
SET(39,159) // MOUSE NOS GETs
SET TIME FORMAT TO "hh:mm"
SET CENTURY ON
SET CONFIRM ON

REQUEST HB_LANG_PT
HB_LangSelect("PT")
HB_SetCodePage("PT850")

#IFDEF __GTWVW__
   wvw_setcodepage(,255)
#ENDIF

*** DEFINIR TIPO DE BANCO DE DADOS: DBFCDX Nativo ***
REQUEST DBFCDX
REQUEST DBFFPT
ANNOUNCE FPTCDX
RDDSETDEFAULT("DBFCDX")
RDDREGISTER( "DBFCDX", 1 ) // RDT_FULL
SET AUTOPEN OFF

*** DEFINIR IDIOMA PORTUGUÊS ***
REQUEST HB_CODEPAGE_PT850 &&& PARA INDEXAR CAMPOS ACENTUADOS
HB_SETCODEPAGE("PT850")   &&& PARA INDEXAR CAMPOS ACENTUADOS

*** LIMPA A TELA E MOSTRA PRIMEIRAS INFORMAÇÕES
CLS
? "*** MEGASENA ***"
? "SORTEIOS SÃO REALIZADOS ÀS QUARTAS E SÁBADOS"
?
dBANCO := FILEDATE("SENA.DBF") // DATA DE GERAÇÃO DO ARQUIVO SENA.DBF
? "HOJE: "+DTOC(DATE()) + " - ÚLTIMA CARGA: "+DTOC(dBANCO)
?

IF EMPTY(dBANCO) .OR. DATE() # dBANCO
   IF (ALERT("ATUALIZA ARQUIVOS AGORA?", {"SIM", "NÃO"}))=1

      *** BAIXA ARQUIVO COM OS RESULTADOS DA INTERNET AUTOMATICAMENTE
      cURL := "http://www1.caixa.gov.br/loterias/_arquivos/loterias/D_megase.zip"
      oHTTP := TIpClientHttp():new( cURL )
      cARQ := "D_MEGA.HTM" // ARQUIVO COM OS RESULTADOS DOS SORTEIOS
      cZIP := "D_megase.zip"
      IF oHTTP:OPEN()
         ? "BAIXANDO ARQUIVO COM OS RESULTADOS DA INTERNET..."
         ? cURL
         ?
         cBIN := oHttp:readAll() // BAIXA ARQUIVO E GRAVA EM cBIN
         oHTTP:CLOSE()
         Memowrit( cZIP, cBIN )  // CRIA ARQUIVO COM cBIN

         IF FILE(cZIP)
            ? cZIP, ALLTRIM(STR( HB_FSIZE(cZIP)/1024 ))+"Kb", FILEDATE(cZIP)
            ? "SUCESSO!"
            ?
         ENDIF

         ? "DESCOMPACTANDO O ARQUIVO '"+cARQ+"' DE 'D_megase.zip'"
         IF HB_UNZIPFILE(cZIP,,,,".\",cARQ)
            ? cARQ, ALLTRIM(STR( HB_FSIZE(cARQ)/1024 ))+"Kb", FILEDATE(cARQ)
            ? "SUCESSO!"
            ?
         ELSE
            ? "NÃO FOI POSSÍVEL DESCOMPACTAR O ARQUIVO '"+cARQ+"' AUTOMATICAMENTE"
            ? "DESCOMPACTE-O MANUALMENTE AQUI NESTA PASTA DO PROGRAMA"
            ?
         ENDIF
      ELSE
         ? "Erro de conexão:", oHttp:lastErrorMessage()
         ? "BAIXE O ARQUIVO "+cURL+ " MANUALMENTE DA INTERNET E DESCOMPACTE ELE NA PASTA DESTE PROGRAMA."
      ENDIF

      IF !FILE(cARQ)
         ? "NÃO É POSSÍVEL ATUALIZAR SEM O ARQUIVO '"+cARQ+"'."
         ? "ABORTANDO PROGRAMA..."
         QUIT
      ENDIF

      *** RECIPIENTE DO ARQUIVO IMPORTADO
      ? TIME()+" - CRIANDO BANCO DE DADOS RECIPIENTE DO ARQUIVO D_MEGA.HTM..."
      RUN ("DEL SENA.DBF")
      aDBF = {}
      aadd(aDBF, {"TAG",   "C",    4, 0})
      aadd(aDBF, {"DATA",  "C",   10, 0}) // PEGAR DATA SORTEIO COMO MARCO INICIAL
      aadd(aDBF, {"RESTO", "C", 3000, 0})
      dbcreate("SENA.DBF", aDBF)

      ? TIME()+" - RENOMEANDO O ARQUIVO D_MEGA.HTM P/ D_MEGA.TXT P/ IMPORTAÇÃO DAS INFORMAÇÕES..."
      IF FILE("D_MEGA.HTM")
         RUN ("DEL D_MEGA.TXT")
         RUN RENAME D_MEGA.HTM D_MEGA.TXT
      ELSEIF !FILE("D_MEGA.TXT")
             ? "ALERTA: FALTA BAIXAR ARQUIVO COM OS RESULTADOS DA MEGASENA"
             ? "ABORTANDO..."
             QUIT
      ENDIF

      ? TIME()+" - IMPORTANDO TODAS AS INFORMAÇÕES DO ARQUIVO D_MEGA.HTM PARA SENA.DBF..."
      USE SENA ALIAS SE EXCLUSIVE NEW
      APPEND FROM D_MEGA.TXT SDF

      ? TIME()+" - CRIANDO ARQUIVO SORTEIOS.DBF P/ ARMAZENAR SÓ AS DEZENAS JÁ SORTEADAS..."
      IF FILE("SORTEIOS.DBF")
         RUN ("DEL SORTEIOS.DBF")
      ENDIF
      aDBF = {}
      aadd(aDBF, {"DEZ1", "N", 2, 0})
      aadd(aDBF, {"DEZ2", "N", 2, 0})
      aadd(aDBF, {"DEZ3", "N", 2, 0})
      aadd(aDBF, {"DEZ4", "N", 2, 0})
      aadd(aDBF, {"DEZ5", "N", 2, 0})
      aadd(aDBF, {"DEZ6", "N", 2, 0})
      dbcreate("SORTEIOS.DBF", aDBF)

      ? TIME()+" - LENDO O ARQUIVO SENA.DBF PARA GRAVAR AS DEZENAS SORTEADAS EM SORTEIOS.DBF..."
      USE SORTEIOS ALIAS DEZ EXCLUSIVE NEW
      SELECT SE // SENA.DBF
      SE->(DBGOTOP()) // POSICIONA NO 1° REGISTRO

      DO WHILE !SE->(EOF()) // FAÇA ENQUANTO NÃO É FIM DO ARQUIVO
         dSORTEIO := CTOD(SE->DATA) // TRANSFORMA CAMPO CARACTER PARA DATA, SE FOR DATA.
         IF !EMPTY(dSORTEIO)
            // SE TRANSFORMOU, O CAMPO É DATA. NO CASO, A DATA DO SORTEIO.
            // AS 6 LINHAS SEGUINTES SÃO AS DEZENAS SORTEADAS.
            SE->(DBSKIP()) // PULA P/ PROXIMA LINHA

            DEZ->(DBAPPEND()) // INSERE REGISTRO EM BRANCO

            // AS 6 LINHAS SEGUINTES SÃO AS DEZENAS SORTEADAS
            DEZ->DEZ1 := VAL( LEFT(SE->DATA,2) )
            SE->(DBSKIP()) // PULA P/ PROXIMA LINHA

            DEZ->DEZ2 := VAL( LEFT(SE->DATA,2) )
            SE->(DBSKIP())

            DEZ->DEZ3 := VAL( LEFT(SE->DATA,2) )
            SE->(DBSKIP())

            DEZ->DEZ4 := VAL( LEFT(SE->DATA,2) )
            SE->(DBSKIP())

            DEZ->DEZ5 := VAL( LEFT(SE->DATA,2) )
            SE->(DBSKIP())

            DEZ->DEZ6 := VAL( LEFT(SE->DATA,2) )
         ENDIF
         SE->(DBSKIP())
      ENDDO
      SE->(DBCOMMIT()) // DESPEJA CACHE NO DISCO, FORÇA GRAVAÇÃO.

      ? TIME()+" - CRIANDO ARQUIVO RANKING.DBF P/ RANKING DAS DEZENAS MAIS SORTEADAS..."
      RUN ("DEL RANKING.DBF")
      RUN ("DEL RANKING.CDX")

      // AS 6 DEZENAS NEM SEMPRE CONTÉM OS NÚMEROS MAIS SORTEADOS
      // POR ISSO FAREMOS UM RANKING PARA CADA UMA DAS 6 DEZENAS
      // ASSIM AUMENTAMOS A CHANCE
      aDBF = {}
      aadd(aDBF, {"DEZ1", "N", 2, 0}) // DEZENA
      aadd(aDBF, {"RPT1", "N", 5, 0}) // VEZES QUE ELA SE REPETE
      aadd(aDBF, {"RNK1", "N", 2, 0}) // RANKING: POSIÇÃO EM QUE OCUPA ENTRE AS MAIS SORTEADAS
      aadd(aDBF, {"DEZ2", "N", 2, 0})
      aadd(aDBF, {"RPT2", "N", 5, 0})
      aadd(aDBF, {"RNK2", "N", 2, 0})
      aadd(aDBF, {"DEZ3", "N", 2, 0})
      aadd(aDBF, {"RPT3", "N", 5, 0})
      aadd(aDBF, {"RNK3", "N", 2, 0})
      aadd(aDBF, {"DEZ4", "N", 2, 0})
      aadd(aDBF, {"RPT4", "N", 5, 0})
      aadd(aDBF, {"RNK4", "N", 2, 0})
      aadd(aDBF, {"DEZ5", "N", 2, 0})
      aadd(aDBF, {"RPT5", "N", 5, 0})
      aadd(aDBF, {"RNK5", "N", 2, 0})
      aadd(aDBF, {"DEZ6", "N", 2, 0})
      aadd(aDBF, {"RPT6", "N", 5, 0})
      aadd(aDBF, {"RNK6", "N", 2, 0})
      dbcreate("RANKING.DBF", aDBF)

      USE RANKING ALIAS RNK EXCLUSIVE NEW
      // CRIANDO ARQUIVO DE ÍNDICES
      INDEX ON STRZERO(DEZ1,2) TAG DEZ1 TO RANKING
      INDEX ON DESCEND( STRZERO(RPT1,2) )   TAG RPT1 TO RANKING
      INDEX ON STRZERO(RNK1,2) TAG RNK1 TO RANKING
      INDEX ON STRZERO(DEZ2,2) TAG DEZ2 TO RANKING
      INDEX ON DESCEND( STRZERO(RPT2,2) )   TAG RPT2 TO RANKING
      INDEX ON STRZERO(RNK2,2) TAG RNK2 TO RANKING
      INDEX ON STRZERO(DEZ3,2) TAG DEZ3 TO RANKING
      INDEX ON DESCEND(STRZERO(RPT3,2)  )   TAG RPT3 TO RANKING
      INDEX ON STRZERO(RNK3,2) TAG RNK3 TO RANKING
      INDEX ON STRZERO(DEZ4,2) TAG DEZ4 TO RANKING
      INDEX ON DESCEND(STRZERO(RPT4,2)  )   TAG RPT4 TO RANKING
      INDEX ON STRZERO(RNK4,2) TAG RNK4 TO RANKING
      INDEX ON STRZERO(DEZ5,2) TAG DEZ5 TO RANKING
      INDEX ON DESCEND(STRZERO(RPT5,2)  )   TAG RPT5 TO RANKING
      INDEX ON STRZERO(RNK5,2) TAG RNK5 TO RANKING
      INDEX ON STRZERO(DEZ6,2) TAG DEZ6 TO RANKING
      INDEX ON DESCEND(STRZERO(RPT6,2) )   TAG RPT6 TO RANKING
      INDEX ON STRZERO(RNK6,2) TAG RNK6 TO RANKING
      SET INDEX TO RANKING // ABRINDO ARQUIVO DE ÍNDICES

      ? TIME()+" - LEVANTANDO INFORMAÇÕES SOBRE CADA BOLA SORTEADA..."

      // VAMOS CRIAR 60 REGISTROS EM BRANCO P/ GUARDAR AS INFORMAÇÕES
      FOR X=1 TO 60
          RNK->(DBAPPEND())
      NEXT

      ? "1ª BOLA:"
      ? TIME()+" - VERIFICANDO QUANTAS VEZES CADA DEZENA FOI SORTEADA..."
      RNK->(ORDSETFOCUS("DEZ1")) // POR ORDEM DE DEZENA
      DEZ->(DBGOTOP())
      RNK->(DBGOTOP())
      DO WHILE !DEZ->(EOF())
         IF !RNK->(DBSEEK( STRZERO(DEZ->DEZ1,2) ))
            RNK->(DBGOTOP()) // POSICIONA NO INICIO DO ARQUIVO
            DO WHILE !EMPTY(RNK->DEZ1) // DESCE ATÉ ACHAR UM CAMPO EM BRANCO
               RNK->(DBSKIP())
            ENDDO

            RNK->DEZ1 := DEZ->DEZ1
            RNK->RPT1 := 1
         ELSE
            RNK->RPT1++
         ENDIF
         DEZ->(DBSKIP())
      ENDDO

      ? TIME()+" - FAZENDO O RANKING DAS MAIS SORTEADAS..."
      RNK->(ORDSETFOCUS("RPT1")) // POR ORDEM DE REPETIÇÃO DA DEZENA
      RNK->(DBGOTOP())
      nRANK := 1
      DO WHILE !RNK->(EOF())
         RNK->RNK1 := nRANK++
         RNK->(DBSKIP())
      ENDDO

      ? "2ª BOLA:"
      ? TIME()+" - VERIFICANDO QUANTAS VEZES CADA DEZENA FOI SORTEADA..."
      RNK->(ORDSETFOCUS("DEZ2")) // POR ORDEM DE DEZENA
      DEZ->(DBGOTOP())
      RNK->(DBGOTOP())
      DO WHILE !DEZ->(EOF())
         IF !RNK->(DBSEEK( STRZERO(DEZ->DEZ2,2) ))
            RNK->(DBGOTOP()) // POSICIONA NO INICIO DO ARQUIVO
            DO WHILE !EMPTY(RNK->DEZ2) // DESCE ATÉ ACHAR UM CAMPO EM BRANCO
               RNK->(DBSKIP())
            ENDDO

            RNK->DEZ2 := DEZ->DEZ2
            RNK->RPT2 := 1
         ELSE
            RNK->RPT2++
         ENDIF
         DEZ->(DBSKIP())
      ENDDO

      ? TIME()+" - FAZENDO O RANKING DAS MAIS SORTEADAS..."
      RNK->(ORDSETFOCUS("RPT2")) // POR ORDEM DE REPETIÇÃO DA DEZENA
      RNK->(DBGOTOP())
      nRANK := 1
      DO WHILE !RNK->(EOF())
         RNK->RNK2 := nRANK++
         RNK->(DBSKIP())
      ENDDO

      ? "3ª BOLA:"
      ? TIME()+" - VERIFICANDO QUANTAS VEZES CADA DEZENA FOI SORTEADA..."
      RNK->(ORDSETFOCUS("DEZ3")) // POR ORDEM DE DEZENA
      DEZ->(DBGOTOP())
      RNK->(DBGOTOP())
      DO WHILE !DEZ->(EOF())
         IF !RNK->(DBSEEK( STRZERO(DEZ->DEZ3,2) ))
            RNK->(DBGOTOP()) // POSICIONA NO INICIO DO ARQUIVO
            DO WHILE !EMPTY(RNK->DEZ3) // DESCE ATÉ ACHAR UM CAMPO EM BRANCO
               RNK->(DBSKIP())
            ENDDO

            RNK->DEZ3 := DEZ->DEZ3
            RNK->RPT3 := 1
         ELSE
            RNK->RPT3++
         ENDIF
         DEZ->(DBSKIP())
      ENDDO

      ? TIME()+" - FAZENDO O RANKING DAS MAIS SORTEADAS..."
      RNK->(ORDSETFOCUS("RPT3")) // POR ORDEM DE REPETIÇÃO DA DEZENA
      RNK->(DBGOTOP())
      nRANK := 1
      DO WHILE !RNK->(EOF())
         RNK->RNK3 := nRANK++
         RNK->(DBSKIP())
      ENDDO

      ? "4ª BOLA:"
      ? TIME()+" - VERIFICANDO QUANTAS VEZES CADA DEZENA FOI SORTEADA..."
      RNK->(ORDSETFOCUS("DEZ4")) // POR ORDEM DE DEZENA
      DEZ->(DBGOTOP())
      RNK->(DBGOTOP())
      DO WHILE !DEZ->(EOF())
         IF !RNK->(DBSEEK( STRZERO(DEZ->DEZ4,2) ))
            RNK->(DBGOTOP()) // POSICIONA NO INICIO DO ARQUIVO
            DO WHILE !EMPTY(RNK->DEZ4) // DESCE ATÉ ACHAR UM CAMPO EM BRANCO
               RNK->(DBSKIP())
            ENDDO

            RNK->DEZ4 := DEZ->DEZ4
            RNK->RPT4 := 1
         ELSE
            RNK->RPT4++
         ENDIF
         DEZ->(DBSKIP())
      ENDDO

      ? TIME()+" - FAZENDO O RANKING DAS MAIS SORTEADAS..."
      RNK->(ORDSETFOCUS("RPT4")) // POR ORDEM DE REPETIÇÃO DA DEZENA
      RNK->(DBGOTOP())
      nRANK := 1
      DO WHILE !RNK->(EOF())
         RNK->RNK4 := nRANK++
         RNK->(DBSKIP())
      ENDDO

      ? "5ª BOLA:"
      ? TIME()+" - VERIFICANDO QUANTAS VEZES CADA DEZENA FOI SORTEADA..."
      RNK->(ORDSETFOCUS("DEZ5")) // POR ORDEM DE DEZENA
      DEZ->(DBGOTOP())
      RNK->(DBGOTOP())
      DO WHILE !DEZ->(EOF())
         IF !RNK->(DBSEEK( STRZERO(DEZ->DEZ5,2) ))
            RNK->(DBGOTOP()) // POSICIONA NO INICIO DO ARQUIVO
            DO WHILE !EMPTY(RNK->DEZ5) // DESCE ATÉ ACHAR UM CAMPO EM BRANCO
               RNK->(DBSKIP())
            ENDDO

            RNK->DEZ5 := DEZ->DEZ5
            RNK->RPT5 := 1
         ELSE
            RNK->RPT5++
         ENDIF
         DEZ->(DBSKIP())
      ENDDO

      ? TIME()+" - FAZENDO O RANKING DAS MAIS SORTEADAS..."
      RNK->(ORDSETFOCUS("RPT5")) // POR ORDEM DE REPETIÇÃO DA DEZENA
      RNK->(DBGOTOP())
      nRANK := 1
      DO WHILE !RNK->(EOF())
         RNK->RNK5 := nRANK++
         RNK->(DBSKIP())
      ENDDO

      ? "6ª BOLA:"
      ? TIME()+" - VERIFICANDO QUANTAS VEZES CADA DEZENA FOI SORTEADA..."
      RNK->(ORDSETFOCUS("DEZ6")) // POR ORDEM DE DEZENA
      DEZ->(DBGOTOP())
      RNK->(DBGOTOP())
      DO WHILE !DEZ->(EOF())
         IF !RNK->(DBSEEK( STRZERO(DEZ->DEZ6,2) ))
            RNK->(DBGOTOP()) // POSICIONA NO INICIO DO ARQUIVO
            DO WHILE !EMPTY(RNK->DEZ6) // DESCE ATÉ ACHAR UM CAMPO EM BRANCO
               RNK->(DBSKIP())
            ENDDO

            RNK->DEZ6 := DEZ->DEZ6
            RNK->RPT6 := 1
         ELSE
            RNK->RPT6++
         ENDIF
         DEZ->(DBSKIP())
      ENDDO

      ? TIME()+" - FAZENDO O RANKING DAS MAIS SORTEADAS..."
      RNK->(ORDSETFOCUS("RPT6")) // POR ORDEM DE REPETIÇÃO DA DEZENA
      RNK->(DBGOTOP())
      nRANK := 1
      DO WHILE !RNK->(EOF())
         RNK->RNK6 := nRANK++
         RNK->(DBSKIP())
      ENDDO

      RNK->(DBCOMMIT())
      CLOSE ALL
      ?
      ? "INFORMAÇÕES COMPLETAS!"
      ? "PRESSIONE UMA TECLA P/ CONTINUAR"
      INKEY(0)
   ENDIF
ENDIF


*** PARTE DO PROGRAMA QUE SORTEIA OS NÚMEROS ***-------------------------

USE RANKING ALIAS RNK EXCLUSIVE NEW
SET INDEX TO RANKING

RNK->(ORDSETFOCUS("RPT1")) // POR REPETIÇÃO/OCORRENCIA
RNK->(DBGOTOP())

CLS
@ 00,00 SAY PADC("*** Ranking da MEGA SENA ***",80)
@ 01,00 SAY PADC("Sorteia no Ranking dos sorteios",80)

nAPOSTAS := nDE := nATE := nDEZENAS := 0
@ 03,10 SAY "QUANTAS APOSTAS?.............:" GET nAPOSTAS PICT "999"

* @ 04,10 SAY "CARTELA DE (6-10)............:" GET nDEZENAS RANGE 6,10 PICT "99"
@ 04,10 SAY "CARTELA DE 6 DEZENAS"; nDEZENAS := 6

@ 05,10 SAY "CLASSIFICAÇÃO ENTRE..........:" GET nDE  PICT "99"
@ 05,44 SAY "E" GET nATE PICT "99" VALID nATE > nDE
READ

@ 07,00 SAY "Números sorteados entre "+str(nDE,2)+" e "+STR(nATE,2)+" do Ranking:"
LL := 9
SETPOS(LL,00)
aCARTELA := {} // CONTROLAR NUMEROS DA CARTELA PARA NAO REPETIR
aJOGOS   := {}
aEMPATE  := {}

FOR X=1 TO nAPOSTAS

    FOR S=1 TO nDEZENAS
        // aCARTELA TERÁ  DEZENAS

        DO WHILE .T.
           RNK->(ORDSETFOCUS("RNK"+STR(S,1) ))
           RNK->(DBGOTOP())

           // SORTEIA ENTRE A CLASSIFICAÇÃO DO RANKING ESCOLHIDA
           nSORTE := HB_RANDOMINT(nDE, nATE )
           nSORTE := STRZERO(nSORTE,2)

           RNK->(DBSEEK(nSORTE)) // POSICIONA NA DEZENA DE NÚMERO  DO RANKING

           bDEZ := &( "{|| RNK->DEZ"+STR(S,1)+" }" ) // CODEBLOCK COM O NOME DO CAMPO
           nDEZ := EVAL( bDEZ ) // VALOR DO CAMPO

           // TESTA SE HÁ EMPATADOS NO RANKING
           bRPT := &( "{|| RNK->RPT"+STR(S,1)+" }" ) // CODEBLOCK COM O NOME DO CAMPO
           nRPT := EVAL( bRPT ) // VALOR QUE A DEZENA SE REPETIU P/ OCUPAR ESTE LUGAR NO RANKING

           RNK->(ORDSETFOCUS("RPT"+STR(S,1) ))
           RNK->(DBGOTOP())
           RNK->(DBSEEK( STRZERO(nRPT,2) )) // POSICIONA NA 1ª DEZENA QUE SE REPETIU IGUAL A DEZENA SORTEADA DO RANKING

           RNK->(DBSKIP())

           IF EVAL(bRPT) = nRPT // HÁ EMPATADOS?

              DO WHILE EVAL(bRPT) = nRPT // FAÇA ENQUANTO MESMA REPETIÇÃO DA DEZENA NO RANKING
                 aADD(aEMPATE, EVAL(bDEZ) )
                 RNK->(DBSKIP())
              ENDDO

              nEMPATES := LEN(aEMPATE)
              IF nEMPATES > 0 // HÁ EMPATES NO RANKING
                 nSORTE := HB_RANDOMINT(1, nEMPATES )
                 nDEZ   := aEMPATE[nSORTE] // SORTEIA UM ENTRE OS EMPATADOS DO RANKING
              ENDIF

              aEMPATE := {} // ZERA MATRIZ DE EMPATES
           ENDIF

           IF aSCAN(aCARTELA, nDEZ) > 0
              // JÁ SORTEIOU ESTA DEZENA NESTA CARTELA
              LOOP // VOLTA
           ENDIF
           aADD(aCARTELA, nDEZ)
           EXIT
        ENDDO
    NEXT

    aSORT(aCARTELA) // COLOCA MATRIZ DAS 6 DEZENAS EM ORDEM CRESCENTE
                    // FACILITA IDENTIFICAÇÃO E ANULAÇÃO DE CARTELAS IGUAIS

    *** MOSTRA DEZENAS SORTEADAS NA TELA
    FOR T=1 TO nDEZENAS
        @ LL,COL()+2 SAY aCARTELA[T]
    NEXT

    SETPOS(++LL,0)

    *** TESTA SE NÃO HÁ CARTELAS IGUAIS
    IF aSCAN(aJOGOS, aCARTELA) > 0 // SE JÁ TEM aCARTELA EM aJOGOS
       LOOP // SE JÁ TEM, VOLTA E REPETE SORTEIO DA CARTELA
    ENDIF

    aADD(aJOGOS, aCARTELA) // ACRESCENTA aCARTELA EM aJOGOS
    aCARTELA := {}         // NOVA CARTELA ZERADA
NEXT
INKEY(0)