La fecha 0, es 1980 conforme a ciertos sistemas (UNIX) y a partir de ahí empiezan a contar (proceden de usar valores en octal 0-7 para guardarlas)...
Recuerdo por ejemplo que versiones antiguas de Winrar, si no indicabas fecha, al extraerlos te asignaba la fecha 0, que según en que sistema lo descomprimieras te asignaba la fecha 0, que constare para ese sistema.

Por otro lado, que tengas ficheros de un año y tu jures que son de otro... primero deberías fijarte que fecha es la que estás mirando, ya que suele estar más presente la fecha de la 'ultima modificación' que la de creación. Si es la de creación, pues no hay forma de decirte que haya pasado en tu equipo, quizás tuvieras mal la fecha (año del equipo) cuando el fichero fue creado, pero si no lo sabes tú, no lo va a saber nadie...

...y no, eso del efecto 2000 era y fue una tontería que solo se daba en diseños muy específicos, en PCs no se daba y era fácil comprobarlo porque la fecha se podía y puede modificar avanzándola hasta el límite que permite el sistema y verás que si lo dejas... al día siguiente 'retorna a 0'.
Entonces, salvo que haya algo programado para que se ejecute con fecha 0, ó para que no se ejecute si es fecha 0, no pasa absolutamente nada a pesar de que tal salto suponga un cambio no solo de año, si no de mes y día de la semana.

En general cuando se programan cosas se programan para x hora, todos los días o para x día de la semana (es decir que se ejecute a intervalos de x tiempo) y esos suponiendo que no tenga un contador individual que es lo preferible, ya que la fecha y la hora se puede cambiar, no puedes arriesgarte a depender de la fecha y hora si es algo crítico tan crítico que puede causar algo 'catastrófico' y por tanto usas un contador propio que no pueda ser cambiado por un usuario medio atontado que no sabe lo que hace en su puesto de trabajo...

...eran 4 tonterías que deberías ser capaz de corregir...

En cualquier caso aquí el código corregido...

El control de la interfaz...

Private Sub Form_Load()
    With HScroll1
        .Min = 18   ' 15
        .Max = 20   ' 25
        .Value = 19
    End With
End Sub
 
Private Sub HScroll1_Change()
    Label2.Caption = CStr(HScroll1.Value) & " Elementos en juego"
End Sub
 
Private Sub Command1_Click()
    Me.MousePointer = vbHourglass
    Call CombinacionesDe6(HScroll1.Value)
    Me.MousePointer = vbDefault
End Sub
 

El código previo y corregido...

Private Sub CombinacionesDe6(ByVal Cantidad As Byte)
    Dim Max As Integer, Total As Long, combinacion   As String
    Dim i As Integer, j As Integer, k As Integer, l As Integer, m As Integer, n As Integer
    Dim ci As String, cj As String, ck As String, cl As String, cm As String, cn As String
 
    Valores = GetArrayDeValores(Cantidad)
    If (SizeArray > 0) Then
        List1.Clear
        List1.Visible = False   ' Esto hará que el añadido sea mucho más rápido
        Max = UBound(Valores)
 
        For i = 0 To Max - 5
            ci = Format2Digitos(CStr(Valores(i)))
            For j = i + 1 To Max - 4
                cj = ci & Format2Digitos(CStr(Valores(j)))
                For k = j + 1 To Max - 3
                    ck = cj & Format2Digitos(CStr(Valores(k)))
                    For l = k + 1 To Max - 2
                        cl = ck & Format2Digitos(CStr(Valores(l)))
                        For m = l + 1 To Max - 1
                            cm = cl & Format2Digitos(CStr(Valores(m)))
                            For n = m + 1 To Max
                                '.... lo que sea que vayas a hacer... por ejemplo añadirlos al listbox
                                combinacion = cm & Format2Digitos(CStr(Valores(n)))
                                'combinacion = ConcatValues(CStr(Valores(i)), CStr(Valores(j)), CStr(Valores(k)), CStr(Valores(l)), CStr(Valores(m)), CStr(Valores(n)))
                                List1.AddItem combinacion
                                Total = (Total + 1)
                            Next
                        Next
                    Next
                Next
            Next
        Next
 
        List1.Visible = True
        Label1.Caption = "Total Combinaciones: " & CStr(Total)   ' el añadido es bastante rápido, no hace falta ponerlo más que al final, o en todo caso en un bucle previo (si fueran a meterse muchos miles)
    End If
End Sub
 
Private Function GetArrayDeValores(ByVal Cantidad As Byte) As Byte()
    Dim V() As Byte, v18() As String
    Const Val18 As String = "4, 6, 14, 18, 19, 20, 21, 24, 26, 27, 31, 32, 35, 36, 40, 41, 42, 47, 49"
    Const Val19 As String = "33", Val20 As String = "11"
 
    If ((Cantidad < 18) Or (Cantidad > 20)) Then
        MsgBox "No se ha contemplado el caso de un array con " & CStr(Cantidad) & " de ítems... " & vbCrLf & "Valores aceptados actualmente: 18-20"
        SizeArray = 0
    Else
        v18 = Split(Val18, ", ")        ' pasamos la constante a un array de strings
        ReDim V(0 To Cantidad)       ' dimensionamos el array en la cantidad deseada
        For k = 0 To 18                 ' pasamos los 18 valores del array de strings al array de bytes
            V(k) = CByte(v18(k))
        Next
 
        If (Cantidad >= 19) Then
            V(19) = CByte(Val19)  ' Si se solicitó 19 o 20 valores, pasamos el 19º
            If (Cantidad = 20) Then V(20) = CByte(Val20)  ' ídem para el 20º
        End If
 
        SizeArray = Cantidad
        GetArrayDeValores = V   ' devolvemos el array al tamaño solicitado y con los valores asignados.
    End If
End Function
 
 
'Private Function ConcatValues(i As String, j As String, k As String, l As String, m As String, n As String) As String
'    ConcatValues = Format2Digitos(i) & Format2Digitos(j) & Format2Digitos(k) & Format2Digitos(l) & Format2Digitos(m) & Format2Digitos(n)
'End Function
 
' Formato: 2espacios + valor(2 dígitos) + espacio(s) + separador
Private Function Format2Digitos(ByRef Valor As String, Optional ByVal Size As Byte = 8, Optional ByRef Separador As String = "|") As String
    Dim Salida As String, k As Integer
 
    If (Len(Valor) = 1) Then
        Salida = ("  0" & Valor)
    Else
        Salida = ("  " & Valor)
    End If
 
    k = (Size - (Len(Salida) + Len(Separador)))
    If (k > 0) Then Salida = (Salida & Space$(k))
 
    Format2Digitos = (Salida & Separador)
End Function
 

Y así se ve el resultado... (primera y yltima combinaciones para 20, usando los valores consiganos para 19 y 20.


p.d.: Nota que he cambiado el textbox por un label... (el valor de un resultado no debe poderse editar).
Los valores negativos de cuenta, sucede cuando superan el valor del tipo integer. Ya que es un tipo con signo, solo alcanza hasta los 32768 (0-32767). entonces cuando la lista añade más elementos, sigue sumando para ahora aparecen como negativos.
Puedes hacer los cálculos, pero si superas luego los 65536, seguirá cometiendo errores (culpa de utilizar como contador un tipo entero de 15 bits, pero permitir más añadidos que esa cantidad). El mejor modo de obviar ese problema es llevar tu propio contador.

Rl código lo escribí al vuelo, hay que repasarlo a medida que se transcribe.

No obstante,  mañana lo reviso y lo pruebo y haré las correcciones que precisare.

La verdad es que usar  valores fijos, puede ser útil cuando uno considera que esos valores 'tienen algo especial', pero como esa idea suele resultar falsa, puede ser más interesante considerar utilizar valores aleatorios (no repetidos)...

...de paso variamos el rango de cantidad entre 15 y 25... solo por ilustrar el ejemplo.

private function GetArrayDeValores(byval Cantidad as byte) as byte()
     dim V() as byte, v49(0 to 49) as byte
     dim k as integer, j as integer, n as byte 
 
     if ((Cantidad< 15) or (cantidad > 25)) then
          case else: msgbox "No se ha contemplado el caso de un array con " & cstr(cantidad) & " de ítems... " & vbcrlf & "Valores aceptados actualmente: 15-25"
          SizeArray = 0
    else
         for k= 0 to 49
             v49(k)= k
         next
 
         redim V(0 to cantidad-1)  ' dimensionamos el array en la cantidad deseada
         for k= 0 to cantidad -1  
             j = (49-k)    
             n = Int(j  * Rnd + 1)  ' el +1 impide elegir el índice y valor 0 de v49 pues no se contempla en las loterías (creo).
             V(k) = v49(n)
 
             v49(n) = v49(j): v49(j)= V(k)  ' el tomado se aparta al final, y ya no será elegible (su puesto es ocupado por el último elegible actualmente).
         next 
 
 
         SizeArray = Cantidad
         GetArrayDeValores = V   ' devolvemos el array al tamaño solicitado y con los valores asignados.
    end if
end function
 

Es broma, no?.
Tratas de decir que usas un lenguaje pero que no conoces siquiera como dimensionar arrays?.

En fin...
La forma en que está declarado es un array estático, tendrá tantos elementos como aquellos que se han contenido.
Esa no es la forma adecuada para inicializar arrays que se pretende tengan capacidades más dinámicas.

En un caso como el presente donde pudiera ser el caso de que tuviere diferentes cantidades y valores es preferible meter en una función la creación de cada caso, que además inicialice el array con los valores deseados.
Tampoco es muy util operar el array como de tipo variant, el variant es para otras cosas, como cuando deben contener cosas heterogéneas, si son todas del mismo tipo (numérico, string, fechas, etc...), entonces es preferible hacer que sea de ese tipo...

private SizeArray as interger
private Valores()  as byte
 
private function GetArrayDeValores(byval Cantidad as byte) as byte()
     dim V() as byte, v18() as string
     const Val18 as string = "4, 6, 14, 18, 19, 20, 21, 24, 26, 27, 31, 32, 35, 36, 40, 41, 42, 47, 49"
     const Val19 as string =  33
     const Val20 as string = 11
 
     if ((Cantidad< 18) or (cantidad > 20)) then
          case else: msgbox "No se ha contemplado el caso de un array con " & cstr(cantidad) & " de ítems... " & vbcrlf & "Valores aceptados actualmente: 18-20"
          SizeArray = 0
    else
         v18 = split(Val18, ", ")   ' pasamos la constante a un array de strings
         redim v(0 to cantidad-1)  ' dimsnesionamos el array en la cantidad deseada
         for k= 0 to 18                ' pasamos los 18 valores del array de strings al array de bytes
             v(k) = cbyte(v18(k))
         next 
         if (cantidad >= 19) then v(18)= Val19   ' Si se solicitó 19 o 20 valores, pasamos el 19º
         if (cantidad = 20) then v(19)= Val20   ' ídem para el 20º
 
         SizeArray = Cantidad
         GetArrayDeValores = v   ' devolvemos el array al tamaño solicitado y con los valores asignados.
    end if
end function
 

finalmente puedes hacer con el array devuelto lo que precises....

Private Sub CombinacionesDe6(byval Cantidad as byte)
    dim Max as integer, combinacion as as string 
    dim i as integer, j as integer, k as integer, l as integer, m as integer, n as integer
 
    valores =  GetArrayDeValores(cantidad)
    if (SizeArray >0) then
         list1.clear
         list1.visible = false   ' Esto hará que el añadido sea mucho más rápido
         max = ubound(valores)
 
          for i = 0 to max-5
              for j= i+1 to max-4
                  for k= j+1 to max-3
                      for l = k+1 to max-2
                          for m= l+1 to max-1
                              for n= m+1 to max
                                  '.... lo que sea que vayas a hacer... por ejemplo añadirlos al listbox
                                   combinacion =ConcatValues(cstr(valores(i)), cstr(valores(j)), cstr(valores(k)), cstr(valores(l)), cstr(valores(m)), cstr(valores(n)))
                                   list1.additem combinacion 
                              next
                          next
                      next 
                  next
              next
          next 
 
          list1.visible = true
          Text1.Text = List1.ListCount  ' el añadido es bastante rápido, no hace falta ponerlo más que al final, o en todo caso en un bucle previo (si fueran a meterse muchos miles)
    end if
end function
 

Unas funciones adicionales simplifican modificar el código en adelante... para que tenga otra apariencia en el listado, sin necesidad de tocar la función previa, solo las de formato.

private function ConcatValues(i as string,j as string,k as string, l as string, m as string, n as string) as string 
      ConcatValues= Format2Digitos(i) & Format2Digitos(j) & Format2Digitos(k) & Format2Digitos(l) & Format2Digitos(m) & Format2Digitos(n)
end function
 
' Formato: 2espacios + valor(2 dígitos) + espacio(s) + separador
private function Format2Digitos(byref Valor as string, optional byval Size as byte = 8, optional byref Separador as string = "|") as string 
    dim Salida as string, k as integer 
 
    if (len(valor) = 1) then 
        salida = ("  0" & valor)
    else
        salida = ("  " & valor)
    end if
 
    k= (len(salida) + len(separador) - Size)
    if (k > 0) then salida = salida & Space$(k)
 
    ConcatValues = (Salida & separador)
end function
 

Puedes modificarlo para más valores que solo 18, 19 y 20... siguiendo el patrón o más complejo si es más ambicioso.
Nota que no se deben repetir valores entre las constantes de la función 'GetArrayDeValores'... al mismo tiempo, podrías disponer diferentes valores constantes cuando sean diferentes cantidades (yo en el ejemplo he optado por aceptar los previos e incrementar en uno cada vez).

No creo que haya que explicar nada más, es bastante simple y cualquiera que sepa un mímino de programación debería entenderlo todo sin más problemas. No obstante si tienes alguna laguna siéntente libre de preguntar.

Por la misma razón que aunque tu puedas correr pongamos a 25km/h. no vas por la vida a 25km/h, vas caminas a 5km/h. y en alguna ocasión corres (un bajo porcentaje de tu máxima capacidad). Economía, gasto innecesario... considera además que no depende solo de la capactidad de tu  dispositivo, también de la del dispositivo que transmite los datos que recibes y todos por los que pasa.

Como veo que no respondes, no hay feedback, te abro otro hueco...

Cuando debes hacer ciertas modificaciones, en gráficos de imagen se suelen denominar transformaciones... hay transformaciones de sitio (mover, es decir desplazar una imagen, hacia cualquier posición, suele bastar con añadir los valores de desplazamiento (x,y) a la imagen... hay varias transformaciones simples (incluído la escala), sin mebargo la suma de todas ellas pueden ser aplicada de unsa sola vez en una sola operación que es la trandformación 3d, pues utiliza multiplicacion de matrices para conservar los datos y finalmente aplicarlo una sola vez, al final debe proyectarse (convertirse de vuelta a 2D), para volcarlo en la pantalla.

No obstante si es solo ese caso, esa transformación la que necesitas aplicar y ninguna más (sesgar la imagen), se puede acelerar el caso, ya que en sí no es más que una interpolación de un área de origen a otra área de destino (que toma forma de trapecio).
Es necesario sin embargo, rotar los 4 puntos de la esquina de la imagen original, para tener la posición (y límites) de la imagen final.
Entopnces por cada pixel en el área de destino, debes preguntar cual píxel de origen le corresponde (con o sin interpolación, pero inicialmente y para pruebas mejor toma el píxel más cercano, olvida interpolación lineal, bilineal, cúbica ni nada complejo, salvo que el resultado no resultare satisfactorio, aunque de entrada es bueno una interpolación del píxel más cercano).

Para calcular el píxel en origen, debes descubrir que transformación ha sufrido el pixel en destino (movimiento). Esto son simples matemáticas... si en origen la imagen media 800px de ancho y en destino mide 500, entonces hay un factor de desplazamiento horizontal para cada pixel en destino de 800/500, y verticalmente en cambio va en 'fuga' es decir debe actualizarse por cada distancia cuanto se ha visto afectado verticalmente... son simples cálculos de divisiones y multiplicaciones.
Pero como te digo, al menos para las 4 esquinas si deben calcularse rotacionalmente su destino, ya que delimitan el área de destino y por tanto las medidas que afectan la transformación.

En las API de win2, hay una que se llama 'world transform', al que se le pasan como parámetros la imagen, los puntos de las esquinas y las transformaciones a efectuar y te devuelve la imagen transformada. Desconozco si en tu lenguaje hay acceso a tales funciones directa o indirectamente (que sería una buena opción si quieres resultados sin complicarte en como lograrlo).

Usa una cookie de seguridad para proteger contra ataques que intenten modificar el stack.

Comprueba si la variable 'data_479b08' está establecida, y en tal caso, invoca una función para generar una clave.

Aquí genera una clave criptográfica utilizando la función 'CryptGenKey'.

La clave privada y su ruta...

Cifrando la clave privada...

Id del ransnnware.
Nota que el id que te solicitó, no necesariamente esté ni necesite estar cifrado, quizás simplemente se use como key para localizar 'tus datos', al menos es lo que yo haría, no lo pondría tan simple.


Aquí se importa la clave pública... más arriba había una exportación de la clave

Al final libera recursos...

p.d.:
Por si te sirve, he aquí el pseudocódigo del código ofuscado:

Suerte con tus pesquisas.... suele ser tedioso tener que operar con código ofuscado, pero si tienes suficientes conocimientos de programación algo podrías llegar a sacar...


p.d2.: Nota la llamada a las funciones de la API de criptografía de Win2: CryptGenKey, CryptExportKey, CryptEncrypt, CryptImportKey, CryptDestroyKey... estamos ante RSA.

No.

Tu respuesta sigue constando ahí. Simplemente si lo necesitas para otra cosa, sobran otros detalles.

Hummm... otro de esos mensajes que da hasta pereza leerlo completo.

Veamos, un 'cuadradito' es de cualquier tamaño?. Al menos se puede rechazar el cuadrado de 1x1 píxel?.
Si un 'cuadradito', ya se contó, puede todavía formar parte de otro más grande?.
Si el color blanco refiere al fondo, entonces solo se forman cuadraditos de color negro, o hay más colores?....

Como ves faltan muchos detalles (y no quiero ser exhaustivo), para poder decirte algo concreto y directo.

No obstante si puedo decirte algo más simple y práctico, al menos para que puedas empezar a enforcarlo, indistintamente de las respuestas y lo que tengas en mente.

Considera una imagen (si en tu caso es en B/N, mejor), como una tabla de 'Ceros' y 'Unos'... al ser una tabla, quier decir que con filas por columnas...



Un cuadrado será 'bueno', solo si está completamente delimitado por 'blancos a su alrededor (excepturando las 4 esquinas)...
NOTA: La primera fila se verifica en la función de arriba, aqquí el resto de filas de 11111.... y los perímetros de 0000...

Nota que trabajamos considerando una tabla, un mapa, un array bidimensional de valores 0-1, puede sustraerte de que son colores, así lo ves más sencillo, dibuja en un papel puntitos representando cada píxel negro, y como un valor 1, para comprender la sencillez del algoritmo...

Un cuadrado será bueno, solo si está completamente delimitado por 'blancos a su completo alrededor... pero esto puede no ser tan restrictivo según tus necesidades, no obstante esto es lo que considera el algoritmo, por eso cuando se verifica un candidato, no solo se verifica que el cuadrado esté con todos '1', también que permitrealmente sean 0... (excepto diagonalmente sobre las 4 esquinas).

NOTA: El algoritmo no está optimizado (ni considera cuadrados dentro de cuadrados), tras encontrar una 'cuadrado en una linea', las siguientes líneas de las que forma parte ese cuadrado se ven expuestas a ser buscadas de nuevo.   ...pero así el algoritmo es mucho más sencillo de entender, aunque tarde más en calcular.

Por último, te aclaro que esto es una aproximación genérica según los detalles que necesites (que no me he enterado bien, he tirado por lo lógico que uno puede aceptar como un 'cuadrado'), tendrás que modificarlo a tus necesidades.... y es fácil que a veces al escribir al vuelo se escape o falte un +1, -1... por algún lado.