Tranquilo... esto no es una red social, donde la gente (parece) exigir que le contesten no tardando más de no se qué cuanto tiempo (so pena de enfadarse). Cada uno a su ritmo...

Hice al final también el filtrado para los de 6_0, de dos maneras distintas...
Una de ellas simplemente ignora añadir al listbox, las entradas ilegales (al final quedna así alrededor de la mitad), el otro modo de fitrado es tratarlo como lo que son solo 5 dígitos, arroja unas 15500 combinaciones, pero no lo veo interesante por que contiene así solo 5 combinaciones (pero quien sabe si un oquisiera aparte poner el 6º manualmente).

Mañana lo comprimo en un zip y lo subo a alguna página de descarga...

Ya te he dicho, que el voltaje, no debe ppreocuparte, se asocia a un modelo de memoria, cuando cambia el voltaje, cambia el tipo de memoria.

Si montas el módulo de 8Gb. puedes guardar el otro de 2Gb. o puedes montalro en el otro módulo (en el DIMM-2), no señala nada en el manual de si acepta dos módulos de distinto tamaño, pero en principio si no es memoria pareada, como mínimo no se daña  y lo más que puede ocurrir es que solo reconozca ese de 8Gb.

Ya borré el manual que descargué. Tienes que ver si tu laca acepta el procesador que tu quieras instalarle. El procesador se reconoce en qué zócalos encaja, mira qué zócalo corresponde a tu procesador y si es el mismo que el que quieres montar, valdrá. Tienes que ver las especificaciones de tu procesador y la del nuevo, para ver las diferencias y si estas son notables (sea en velocidad de proceso, cantidad de núcleos, conjunto extra de instrucciones, etc...). Una vez destaques esas diferencias tu mismo podrás juzgar si el precio del mismo justifica (para tí), el cambio.
Ten en cuenta que instalar un procesador puede conllevar que debas actualizar los drivers, y es factible que según el S.O. instalado no arranque. Puede forzarte un formateo, o por lo menos montar otro disco (y dejar el actual para cuando montares el 'viejo' procesador... si te decides por ello, el consejo es pués que lo dejes para cuando tengas pensado formatear.

Cuánto mejor que todos estos países se dediquen a tecnología y no a lo militar... a la paz y no a la guerra, a los ciudadanos y no a los militares. Felicitaciones.

jajaja... en realidad el país de impacto, es cualquiera en el planeta... teniendo en cuenta la órbita que describen, todo el planeta está a su alcance, todo dependerá del momento exacto en que haga la reentrada en la atmósfera.

Cuando haga la reentrada, la temperatura que alcanza, y sin control, lo destrozará por completo... aunque cabe que caiga algún trozo de cierto tamaño según sea el diseño y alguna pieza pesada quede 'protegida'. Aunque suelen fundirse, cuando el ángulo de reentrada en estos casos es muy bajo, lo que implica mucho tiempo de reentrada y por tanto se puede llegar fundir casi por completo... Si el ángulo es grande, es cuando menos tarda en atravesar y por tanto cuando puede haber trozos más grandes.

p.d.: Los chinos se están luciendo... primero 'nos lanzan' un virus y ahora un cohete fuera de control... a ver qué es lo próximo. 

Web: https://es.msi.com/Motherboard/support/760GM-P23-FX#down-bios
De allí puedes bajar software para actualizar tu placa base...
El manual también se localiza allí...
...y mira lo que dice:

Y más abajo referente a la instalación de memoria:

En el BIOS, además suele haber a veces información útil... En tu caso es preferible que no toques nada, déjalo en auto, pero está bien al menos mirar las opciones activas:
(en la  ficha 'Cell Menu')

Resumiendo, si yo fuera tu compraría al menos 1 módulo DDR3 de 8Gb. a 1333Mhz. y si el dinero no es un limitante 2 módulos, así tienes 16Gb. a la mayor velocidad que permite tu placa base... y con ello debería durarte algunos años más, sobretodo si lo acompañas de alguna unidad SSD (que se ve viejo el equipo) dedicado para el S.O.

---

pd.:

A veces no hay que hacer mucho caso a los vídeos de youtube. Si es importante prestar atención a lo que tu equipo demanda, peor para no malgastar el dinero. Ciertas configuraciones simplemente no se admiten, porque hay una patilla (notch), que impide que coloques un módulo incompatible.
Luego solo resta saber 2 o 3 cosas...

- La velocidad (como te han dicho más arriba), si no son iguales en ambos módulos de memoria, la que se aplica es la que ambos tengan en común, es decir la más baja, porque el módulo de más velocidad podrá ir más lenta, pero la lenta no puede ir más rápido (es de lógica, no?).
- El voltaje: Si conectaras un módulo con un voltaje distinto al que admite la placa base, se dañaría, pero por eso mismo los módulos o bien cambian de nombre y con ello se coloca el 'notch', en otra posición (que impide que encaje el módulo), o bien tiene diferente numero de patillas, luego tampoco encaja.
- Ubicación... muchas placas exigen que de haber un solo módulo, este ocupe el zócalo 1 (normalmente verás en la plaza base a uno de los extremos algo domo DIMM-1, DIMM-2, DIMM-3,etc... (en tu placa solo hay dos). Y otras placas exigen que se coloquen módulos pares (2, 4), no es el caso de tu placa.

En definitiva, salvo que si adquieres 1 solo módulo que se debe montar en el banco 1, no se aplica más 'organizacion '... compra el módulo cuyo precio encaje en tu bolsillo (yo te recomiendo uno DDR3 de 8GB. de 1333Mhz. y si puedes 2, mejor). Y el módulo que tienes lo guardas (de reserva, por cualquier problema que pudiere surgir a futuro).

Descárgate también el software de la web del fabricante (y si es compatible con el S.O. instalado, instálalo), incluso aunque no lo instales es conveniente tenerlo 'por ahí',  por si un día vuelves a una versión previa de tu S.O. que si funcionare con dicho software... en fin es cosa de lo que tengas instalado en tu equipo.

Serías capaz de entender acertadamente el significado de 'lenguaje de propósito general'?.
La mayor parte de los lenguajes de hoy día tan cacareados en todas partes, son de propósito general. Quiere decir que está enfocado a todo.

Algo que se va olvidando y cualquier día, de repente una nueva generación descubrirá como algo apoteósico, orgásmico, la lectura de libros o quizás quede relegado como si fuera un lujo...

'Antiguamente', se solía responder con un tajante: "Read the fucking FAQS"... pero hoy día con la ñoñería y mojigatería de vuelta... está mal visto.

Tengo un momento hoy tras comer, aprovecho para terminarlo...

Antes de nada, es conveniente aclarar que cometí un pequeño error (un '0' donde debí poner una 'O', que como es copia y pega... se tradujo al resto), pero no afecta a lo hecho si no a los que muestro. Esto implica que el numero de combinaciones para los casos de 4-2, 5-1 y 6-0, son mucho menores:
Las combinaciones del caso 4 decenas + 2 unidades son 38.760 y no 143.080
Las combinaciones del caso 5 decenas + 1 unidades son 177.100 y no 402.895
Con el de 6 decenas + 0 unidades (no hay dígitos en el rango 5-9), se dan muchísimos casos ilegales de las 177.100 9 de cada 10 son ilegales... o bien tienen 00, o bien un valor repetido dos veces. Se puedne filtrar con ligeras modificaciones, abajo lo vuelvo a mencionar cuando llegue el momento...

Friend Class Permutas3_3
    Implements ICombina
 
    Const MAX_COMBINAS As UInt32 = 5005
    Private s_Combinas() As String
 
    Public Sub New()
        Call Enumerar()
    End Sub
 
    Public ReadOnly Property Cantidad As UInteger Implements ICombina.Cantidad
        Get
            Return MAX_COMBINAS
        End Get
    End Property
 
    Public Sub Enumerar() Implements ICombina.Enumerar
        s_Combinas = EnumeraComb("ABCDEF", "JKLMNO", MAX_COMBINAS) ' 5005 
    End Sub
 
    ' Alfabeto = XYZ   RST
    '  A   B   C   D   E     F   G   H   I   J     K   L   M   N   O
    '  XY  XZ  XR  XS  XT    YX  YZ  YR  YS  YT    ZX  ZY  ZR  ZS  ZT        
    Public Function Tranformar(ByVal Index As Integer, ByRef Decenas() As Byte, ByRef Unidades() As Byte) As String Implements ICombina.Tranformar
        Dim permuta As String = s_Combinas(Index)
        Dim s(0 To 5) As String
        Dim v As Byte, m As Byte, n As Byte, k As Byte
 
        For k = 0 To 5
            v = (Strings.Asc((permuta.Chars(k))) - 65)
            m = (Decenas(v \ 5) * 10)
            n = (v Mod 5)
 
            If (n < 2) Then
                If (v < 5) Then
                    v = (m + Decenas(n + 1))        ' XY, XZ
                ElseIf (v < 10) Then
                    If (n = 0) Then
                        v = (m + Decenas(n))        ' YX
                    Else
                        v = (m + Decenas(n + 1))    ' YZ
                    End If
                Else
                    v = (m + Decenas(n))            ' ZX, ZY
                End If
            Else
                v = (m + Unidades(n - 2))           ' *R,*S,*T
            End If
 
            If (v < 10) Then s(k) = "0" & v.ToString Else s(k) = v.ToString
        Next
 
        Array.Sort(s)
        Return Join(s, ", ")
    End Function
End Class
 
Friend Class Permutas4_2
    Implements ICombina
 
    Const MAX_COMBINAS As UInt32 = 38760  '143080
    Private s_Combinas() As String
 
    Public Sub New()
        Call Enumerar()
    End Sub
 
    Public ReadOnly Property Cantidad As UInteger Implements ICombina.Cantidad
        Get
            Return MAX_COMBINAS
        End Get
    End Property
 
    Public Sub Enumerar() Implements ICombina.Enumerar
        s_Combinas = EnumeraComb("ABCDEF", "OPQRST", MAX_COMBINAS) ' 38760
    End Sub
 
    ' Alfabeto = WXYZ   RS
    ' A   B   C   D   E     F   G   H   I   J     K   L   M   N   O     P   Q   R   S   T
    ' WX  WY  WZ  WR  WS    XW  XY  XZ  XR  XS    YW  YX  YZ  YR  YS    ZW  ZX  ZY  ZR  ZS
    Public Function Tranformar(ByVal Index As Integer, ByRef Decenas() As Byte, ByRef Unidades() As Byte) As String Implements ICombina.Tranformar
        Dim permuta As String = s_Combinas(Index)
        Dim s(0 To 5) As String
        Dim v As Byte, m As Byte, n As Byte, k As Byte
 
        For k = 0 To 5
            v = (Strings.Asc((permuta.Chars(k))) - 65)
            m = (Decenas(v \ 5) * 10)
            n = (v Mod 5)
 
            If (n < 3) Then
                If (v < 5) Then
                    v = (m + Decenas(n + 1))        ' WX, WY, WZ
                ElseIf (v < 10) Then
                    If (n = 0) Then
                        v = (m + Decenas(n))        ' XW
                    Else
                        v = (m + Decenas(n + 1))    ' XY, XZ
                    End If
                ElseIf (v < 15) Then
                    If (n < 2) Then
                        v = (m + Decenas(n))        ' YW, YX
                    Else
                        v = (m + Decenas(n + 1))    ' YZ
                    End If
                Else
                    v = (m + Decenas(n))            ' ZW, ZX, ZY
                End If
            Else
                v = (m + Unidades(n - 3))           ' *R,*S
            End If
 
            If (v < 10) Then s(k) = "0" & v.ToString Else s(k) = v.ToString
        Next
 
        Array.Sort(s)
        Return Join(s, ", ")
    End Function
End Class
 
Friend Class Permutas5_1
    Implements ICombina
 
    Const MAX_COMBINAS As UInt32 = 177100  '402895
    Private s_Combinas() As String
 
    Public Sub New()
        Call Enumerar()
    End Sub
 
    Public ReadOnly Property Cantidad As UInteger Implements ICombina.Cantidad
        Get
            Return MAX_COMBINAS
        End Get
    End Property
 
    Public Sub Enumerar() Implements ICombina.Enumerar
        s_Combinas = EnumeraComb("ABCDEF", "TUVWXY", MAX_COMBINAS) ' 177.100 
    End Sub
 
    ' Alfabeto: VWXYZ   R
    ' 01  02  03  04  0?    10  12  13  14  1?    20  21  23  24  2?    30  31  32  34  3?    40  41  42  43  4?
    ' A   B   C   D   E     F   G   H   I   J     K   L   M   N   O     P   Q   R   S   T     U   V   X   Y   Z
    ' VW  VX  VY  VZ  VR    WV  WX  WY  WZ  WR    XV  XW  XY  XZ  XR    YV  YW  YX  YZ  YR    ZV  ZW  ZX  ZY  ZR
    Public Function Tranformar(ByVal Index As Integer, ByRef Decenas() As Byte, ByRef Unidades() As Byte) As String Implements ICombina.Tranformar
        Dim permuta As String = s_Combinas(Index)
        Dim s(0 To 5) As String
        Dim v As Byte, m As Byte, n As Byte, k As Byte
 
        For k = 0 To 5
            v = (Strings.Asc((permuta.Chars(k))) - 65)
            m = (Decenas(v \ 5) * 10)
            n = (v Mod 5)
 
            If (n < 4) Then
                If (v < 5) Then
                    v = (m + Decenas(n + 1))        ' VW, VX, VY, VZ
                ElseIf (v < 10) Then
                    If (n = 0) Then
                        v = (m + Decenas(n))        ' WV
                    Else
                        v = (m + Decenas(n + 1))    ' WX, WY, WZ
                    End If
                ElseIf (v < 15) Then
                    If (n < 2) Then
                        v = (m + Decenas(n))        ' XV, XW
                    Else
                        v = (m + Decenas(n + 1))    ' XY, XZ
                    End If
                ElseIf (v < 20) Then
                    If (n < 3) Then
                        v = (m + Decenas(n))        ' YV, YW, YX
                    Else
                        v = (m + Decenas(n + 1))    ' YZ
                    End If
                Else
                    v = (m + Decenas(n))            ' ZV, ZW, ZX, ZY
                End If
            Else
                v = (m + Unidades(n - 4))           ' *R
            End If
 
            If (v < 10) Then s(k) = "0" & v.ToString Else s(k) = v.ToString
        Next
 
        Array.Sort(s)
        Return Join(s, ", ")
    End Function
End Class
 
Friend Class Permutas6_0
    Implements ICombina
 
    Const MAX_COMBINAS As UInt32 = 177100 
    Private s_Combinas() As String
 
    Public Sub New()
        Call Enumerar()
    End Sub
 
    Public ReadOnly Property Cantidad As UInteger Implements ICombina.Cantidad
        Get
            Return MAX_COMBINAS
        End Get
    End Property
 
    Public Sub Enumerar() Implements ICombina.Enumerar
        s_Combinas = EnumeraComb("ABCDEF", "TUVWXY", MAX_COMBINAS)   ' 177.100  
    End Sub
 
    ' Alfabeto: VWXYZ?   _
    ' 00  01  02  03  04    10  11  12  13  14    20  21  22  23  24    30  31  32  33  34    40  41  42  43  44
    ' A   B   C   D   E     F   G   H   I   J     K   L   M   N   O     P   Q   R   S   T     U   V   W   X   Y
    ' VV  VW  VX  VY  VZ    WV  WW  WX  WY  WZ    XV  XW  XX  XY  XZ    YV  YW  YX  YY  YZ    ZV  ZW  ZX  ZY  ZZ
    Public Function Tranformar(ByVal Index As Integer, ByRef Decenas() As Byte, ByRef Unidades() As Byte) As String Implements ICombina.Tranformar
        Dim permuta As String = s_Combinas(Index)
        Dim s(0 To 6) As String
        Dim v As Byte, m As Byte, n As Byte, k As Byte
 
        For k = 0 To 5  ' el 0 se reserva (caso especial, para comparar un item con el previo)
            v = (Strings.Asc((permuta.Chars(k))) - 65)
            m = (Decenas(v \ 5) * 10)
            n = (v Mod 5)
 
            If (m = n) Then
                s(0) = " --- Combinacion ilegal --- "  ' aparece '00' 
            End If
            v = (m + n)
            If (v < 10) Then s(k + 1) = "0" & v.ToString Else s(k + 1) = v.ToString
        Next
 
        Array.Sort(s)
        For k = 1 To 5
            If (s(k) = s(k - 1)) Then
                s(0) = " --- Combinacion ilegal --- " ' un mismo numero aparece 2 veces.
            End If
        Next
 
        Return Join(s, ", ")
    End Function
End Class
 

Realmente la clase 6_0, es casi idéntica a la clase 5_1 (la enumeración es la misma), pero la transformación de los datos difiere. Más aún puesto que alredededor de 9 de cada 10 son ilegales, creo que es inecesario, o al menos filtrar los valores ilegales. Esto es bastante sencillo, simplemente basta reducirlo desde 6 decenas y 0 unidades a 5 decenas y 0 unidades.
Habria que modificar ligeramente la función del botón, que ahora exige que haya 6 dígitos, para aceptar el caso de 5 dígitos y si son todos unidades, derivarlo a la nueva clase y si no error. El otro cambio a apalicar sería en la función de enumeración que yace en el módulo... todas las referencias a la cantidad (0-5), debería aceptar un valor sensible al tamaño que se entre, lo cual se toma del parámetro 'Inicio' (por ejemplo), reclamando su longitud -1, es 6-1 para todas excepto para esta que sería 5-1...
Si te interesa avisas y rehago esta última clase para filtrar las combinaciones ilegales... una captura de ejemplo.


Por ultimo, quizás intereses conocer el número de la combinación seleccionada en un momento dado... para cualquier referencia de interés:

    Private Sub ListBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ListBox1.SelectedIndexChanged
        Label4.Text = "Indice: " & ListBox1.SelectedIndex.Tostring
    End Sub
 

Hay que mirar el manual de la placa base.
En él se menciona los bancos de memoria que tiene , de qué tipo y si es ECC o no ECC.
Por ejemplo, si resulta que tu placa base admite 2 módulso de 4Gb. pués sería preferible comprar 1 módulo de 4Gb. (y si acaso más adelante otro de 4Gb.), en vez de adquirir uno de 2Gb. para tener 4Gb.

El manual se suele descargar de la web del fabricante, para eso se precisa tener la marca y el modelo de la placa base... dichos datos suelen estar a un laod de la CPU, a menudo entre éste y  la memoria o entre la CPU y la tarjeta gráfica...

Señala la marca y modelo, y veamos si existe aún un punto de descarga en la web del fabricante... (depende de la antigüedad de la propia placa base).

Los muertos contados hasta hace unas horas eran 38... teniendo en cuenta el cambio horario, antes que acabe el día (allí) podrá crecer...