Código de identificación fiscal

El Código de identificación fiscal ('CIF') ha sido hasta 2008 el nombre del sistema de identificación tributaria utilizada en España para las personas jurídicas o entidades en general según regula el Decreto 2423/1975, de 25 de septiembre.

Este Decreto queda derogado con efectos desde el 1 de enero de 2008 por el Real Decreto 1065/2007, de 27 de julio que define el uso del Número de identificación fiscal. Los valores de las letras son ampliados la Orden EHA/451/2008, de 20 de febrero de 2008,^[1] por la que se regula la composición del número de identificación fiscal de las personas jurídicas y entidades sin personalidad jurídica.

Índice

1 Formato del código
- 1.1 Rutinas de cálculo
2 Abreviaturas de las sociedades
3 Véase también
4 Referencias
5 Enlaces externos
- 5.1 Cálculo del CIF

Formato del código [editar]

El CIF se define originariamente en el Decreto 2423/1975^[2] y ha sido modificado en varias ocasiones. La última modificación, antes de su derogación con efectos desde el 1 de enero de 2008, corresponde a la Orden de 3 de julio de 1998^[3] que regula el código de identificación de las personas jurídicas y entidades en general.

El CIF consta de 9 caracteres. El primero (posición 1) es una letra que sigue los siguientes criterios:

A. Sociedades anónimas.
B. Sociedades de responsabilidad limitada.
C. Sociedades colectivas.
D. Sociedades comanditarias.
E. Comunidades de bienes.
F. Sociedades cooperativas.
G. Asociaciones.
H. Comunidades de propietarios en régimen de propiedad horizontal.
J. Sociedades civiles.
K. Formato antiguo.
L. Formato antiguo.
M. Formato antiguo.
N. Entidades no residentes.
P. Corporaciones locales.
Q. Organismos autónomos, estatales o no, y asimilados, y congregaciones e instituciones religiosas.
R. Congregaciones e instituciones religiosas (desde 2008, ORDEN EHA/451/2008)
S. Órganos de la Administración del Estado y comunidades autónomas
V. Sociedad Agraria de Transformación.
W. Establecimientos permanentes de entidades no residentes en España

A continuación se insertan otros ocho dígitos con las siguientes posiciones: las dos primeras indican la provincia, donde los identificadores o claves provinciales son:

Identificador	Provincia
01	Álava
02	Albacete
03, 53, 54	Alicante
04	Almería
05	Ávila
06	Badajoz
07, 57	Islas Baleares
08, 58, 59, 60, 61, 62, 63, 64, 65	Barcelona
09	Burgos
10	Cáceres
11, 72	Cádiz
12	Castellón
13	Ciudad Real
14, 56	Córdoba
15, 70	La Coruña
16	Cuenca
17, 55	Gerona
18	Granada
19	Guadalajara
20	Guipúzcoa
21	Huelva
22	Huesca
23	Jaén
24	León
25	Lérida
26	La Rioja
27	Lugo
28, 78, 79, 80, 81, 82, 83, 84, 85, 86	Madrid
29, 92, 93	Málaga
30, 73	Murcia
31, 71	Navarra
32	Orense
33, 74	Asturias
34	Palencia
35, 76	Las Palmas
36, 27, 94	Pontevedra
37	Salamanca
38, 75	Santa Cruz de Tenerife
39	Cantabria
40	Segovia
41, 91	Sevilla
42	Soria
43, 77	Tarragona
44	Teruel
45	Toledo
46, 96, 97, 98	Valencia
47	Valladolid
48, 95	Vizcaya
49	Zamora
50, 99	Zaragoza
51	Ceuta
52	Melilla

Los cinco siguientes dígitos (posiciones 4 a 8) constituyen un número correlativo de inscripción de la organización en el registro provincial, y el último dígito (posición 9) es un código de control que puede ser un número o una letra :

Será una LETRA si la clave de entidad es K, P, Q ó S.
Será un NUMERO si la entidad es A, B, E ó H.
Para otras claves de entidad: el dígito podrá ser tanto número como letra.

Las operaciones para calcular el dígito de control se realizan sobre los siete dígitos centrales y son las siguientes:

Sumar los dígitos de la posiciones pares. Suma = A
Para cada uno de los dígitos de la posiciones impares, multiplicarlo por 2 y sumar los dígitos del resultado.

Ej.: ( 8 * 2 = 16 --> 1 + 6 = 7 )
Acumular el resultado. Suma = B
Sumar A + B = C
Tomar sólo el dígito de las unidades de C. Lo llamaremos dígito E.
Si el dígito E es distinto de 0 lo restaremos a 10. D=10-E. Esta resta nos da D. Si no, si el dígito E es 0 y si el dígito de control ha de ser numérico entonces D=0 y no hacemos resta.
A partir de D ya se obtiene el dígito de control. Si ha de ser numérico es directamente D y si se trata de una letra se corresponde con la relación:

J = 0, A = 1, B = 2, C= 3, D = 4, E = 5, F = 6, G = 7, H = 8, I = 9

Ejemplo para el CIF A58818501: Utilizamos los siete dígitos centrales = 5881850

Sumamos los dígitos pares: A = 8 + 1 + 5 = 14
Posiciones impares:

5 * 2 = 10 -> 1 + 0 = 1

8 * 2 = 16 -> 1 + 6 = 7

0 * 2 = 0 -> = 0

Sumamos los resultados: B = 1 + 7 + 7 + 0 = 15
Suma parcial: C = A + B = 14 + 15 = 29
El dígito de las unidades de C es 9.
Se lo restamos a 10 y nos da: D = 10 - 9 = 1
Si el dígito de control ha de ser un número es 1 y si ha de ser una letra es la "A"

Rutinas de cálculo [editar]

Como esta parte de obtener el dígito de control puede parecer un poco más complicada, a continuación damos diversas implementaciones.

Implementación en Visual Basic for Applications (VBA)

'Valida que un cif introducido sea correcto
'según la Orden EHA/451/2008
Public Function Valida_CIF(ByVal valor As String) As Boolean
    Dim A As Integer
    Dim B As Integer
    Dim C As Integer
    Dim CIF As String
    Dim CIFDIGITO As String
    Dim i As Integer
 
    A = 0
    B = 0
 
    Valida_CIF = False
 
    If Len(valor) <> 9 Then 'el CIF debe tener 9 cifras
      Exit Function
    End If
 
    CIF = Mid(valor, 2, 7) 'se obtienen los dígitos centrales
    
    CIFDIGITO = Right(valor, 1) 'dígito de control
    
    For i = 1 To 6 Step 2
        A = A + Mid(CIF, i + 1, 1)   'Suma de posiciones pares
        C = 2 * Mid(CIF, i, 1)       'Doble de posiciones impares
        B = B + (C Mod 10) + Int(C / 10)   'Suma de digitos de doble de pares
    Next i
    'para obtener el cálculo de la cifra de la séptima posición que no se trata
    'en el bucle
    B = B + ((2 * Mid(CIF, 7, 1)) Mod 10) + Int((2 * Mid(CIF, 7, 1)) / 10)
 
    'se obtiene la unidad de la cifra total
    C = (10 - ((A + B) Mod 10)) Mod 10
 
    Dim Digito As String
    Dim letras As Variant
    letras = Array("J", "A", "B", "C", "D", "E", "F", "G", "H", "I")
    Select Case (Left(valor, 1))
        'los cif que comienzan por estas letras deben terminar en una letra
        'concreta de la lista anterior
        Case "K", "P", "R", "Q", "S", "W": Digito = letras(C)
 
        'los cif que comienzan por estas letras deben terminar en un dígito
        Case "A", "B", "E", "H", "J", "U", "V": Digito = C
 
        Case "X", "Y", "Z":
        ' Error: es un NIE

        'para el resto de cif, la terminación puede ser un número o una letra
        Case Else
          If IsNumeric(CIFDIGITO) Then
             Digito = C
          Else
             Digito = letras(C)
          End If
    End Select
       Valida_CIF = (CIFDIGITO = Digito)
 
End Function

Implementación en ActionScript

// Validación de CIF de la nueva normativa de la Orden EHA/451/2008, en lenguaje ActionScript para las validaciones en los PDFs
 
var cif = event.value;
var par = 0;
var non = 0;
var letras = "ABCDEFGHJKLMNPRQSUVW";
var caracterControlLetra = "KPQS";
var caracterControlNum = "ABEH";
var i;
var parcial;
var control;
var controlLetra = "JABCDEFGHIJ";
var letraIni = cif.charAt(0);
 
if (cif.length!=9) {
    app.alert("El Cif debe tener 9 dígitos",3);
    event.value="";
}
else
{
    if (letras.indexOf(letraIni.toUpperCase())==-1)
    {
        app.alert("La letra del CIF introducido no es correcta",3);
        event.value="";
    }
    for (i=2;i<8;i+=2) {
        par = par + parseInt(cif.charAt(i));
    }
 
    for (i=1;i<9;i+=2) {
        var nn = 2 * parseInt(cif.charAt(i));
        if (nn > 9) nn = 1 + (nn-10);
        non = non + nn;
    }
 
    parcial = par + non;
 
    control = (10 - ( parcial % 10));
 
 
    if (caracterControlLetra.indexOf(letraIni.toUpperCase()) != -1)
    {
        // El carácter de control deberá ser una letra
 
        if (controlLetra.charAt(control) != cif.charAt(8).toUpperCase())
        {
            app.alert("El Cif no es válido",3);
            event.value ="";
        }
    }
    if (caracterControlNum.indexOf(letraIni.toUpperCase()) != -1)
    {
        // El carácter de control deberá ser un número
 
        if (control == 10) control = 0;
 
        if (control != cif.charAt(8))
        {
            app.alert("El Cif no es válido",3);
            event.value ="";
        }
    }
    if ((caracterControlLetra.indexOf(letraIni.toUpperCase()) == -1) && (caracterControlNum.indexOf(letraIni.toUpperCase()) == -1))
    {
        // En este caso el carácter de control puede ser una letra o un número
 
        if (control == 10)
        {
            control = 0;
        }
        if ((controlLetra.charAt(control) != cif.charAt(8).toUpperCase()) && (control != cif.charAt(8)))
        {
            app.alert("El Cif no es válido",3);
            event.value ="";
        }
    }
}

Implementación en Java

private static final Pattern cifPattern = Pattern.compile("[[A-H][J-N][P-S]UVW][0-9]{7}[0-9A-J]");
 
private static final String CONTROL_SOLO_NUMEROS = "ABEH"; // Sólo admiten números como carácter de control
private static final String CONTROL_SOLO_LETRAS = "KPQS"; // Sólo admiten letras como carácter de control
private static final String CONTROL_NUMERO_A_LETRA = "JABCDEFGHI"; // Conversión de dígito a letra de control.
 
public static boolean validateCif(String cif) {
    try {
        if (!cifPattern.matcher(cif).matches()) {
            // No cumple el patrón
            return false;
        }
 
        int parA = 0;
        for (int i = 2; i < 8; i += 2) {
            final int digito = Character.digit(cif.charAt(i), 10);
            if (digito < 0) {
                return false;
            }
            parA += digito;
        }
 
        int nonB = 0;
        for (int i = 1; i < 9; i += 2) {
            final int digito = Character.digit(cif.charAt(i), 10);
            if (digito < 0) {
                return false;
            }
            int nn = 2 * digito;
            if (nn > 9) {
                nn = 1 + (nn - 10);
            }
            nonB += nn;
        }
 
        final int parcialC = parA + nonB;
        final int digitoE = parcialC % 10;
        final int digitoD = (digitoE > 0) ?
                (10 - digitoE) :
                0;
        final char letraIni = cif.charAt(0);
        final char caracterFin = cif.charAt(8);
 
        final boolean esControlValido =
            // ¿el carácter de control es válido como letra?
            (CONTROL_SOLO_NUMEROS.indexOf(letraIni) < 0
                    && CONTROL_NUMERO_A_LETRA.charAt(digitoD) == caracterFin)
            ||
            // ¿el carácter de control es válido como dígito?
            (CONTROL_SOLO_LETRAS.indexOf(letraIni) < 0
                    && digitoD == Character.digit(caracterFin, 10));
        return esControlValido;
 
    } catch (Exception e) {
        return false;
    }
}

Implementación en C#

public bool validateCif(string cif)
{
    if (string.IsNullOrEmpty(cif)) return false;
    cif = cif.Trim().ToUpper();
 
    //Debe tener una longitud igual a 9 caracteres;
    if (cif.Length != 9) return false;
    // ... y debe comenzar por una letra, la cual pasamos a mayúscula, ... 
    // 
    string firstChar = cif.Substring(0, 1); 
    // ...que necesariamente deberá de estar comprendida en 
    // el siguiente intervalo: ABCDEFGHJNPQRSUVW 
    // 
    string cadena = "ABCDEFGHJNPQRSUVW";
    if (cadena.IndexOf(firstChar) == -1) return false;
    try
    {
        Int32 sumaPar = default(Int32);
        Int32 sumaImpar = default(Int32);
        // A continuación, la cadena debe tener 7 dígitos + el dígito de control. 
        // 
        string cif_sinControl = cif.Substring(0, 8);
        string digits = cif_sinControl.Substring(1, 7);
        for (Int32 n = 0; n <= digits.Length - 1; n += 2)
        {
            if (n < 6)
            {
                // Sumo las cifras pares del número que se corresponderá 
                // con los caracteres 1, 3 y 5 de la variable «digits». 
                // 
                sumaPar += Convert.ToInt32(digits[n + 1].ToString());
            }
            // Multiplico por dos cada cifra impar (caracteres 0, 2, 4 y 6). 
            // 
            Int32 dobleImpar = 2 * Convert.ToInt32(digits[n].ToString());
            // Acumulo la suma del doble de números impares. 
            // 
            sumaImpar += (dobleImpar % 10) + (dobleImpar / 10);
        }
        // Sumo las cifras pares e impares. 
        // 
        Int32 sumaTotal = sumaPar + sumaImpar;
        // Me quedo con la cifra de las unidades y se la resto a 10, siempre 
        // y cuando la cifra de las unidades sea distinta de cero 
        // 
        sumaTotal = (10 - (sumaTotal % 10)) % 10;
        // Devuelvo el Dígito de Control dependiendo del primer carácter 
        // del NIF pasado a la función. 
        //
        string digitoControl = "";
        switch (firstChar)
        {
            case "N":
            case "P":
            case "Q":
            case "R":
            case "S":
            case "W": 
                // NIF de entidades cuyo dígito de control se corresponde 
                // con una letra. 
                // 
                // Al estar los índices de los arrays en base cero, el primer 
                // elemento del array se corresponderá con la unidad del número 
                // 10, es decir, el número cero. 
                // 
                char[] characters = { 'J', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'};
                digitoControl = characters[sumaTotal].ToString();
                break;
            default:
                // NIF de las restantes entidades, cuyo dígito de control es un número. 
                // 
                digitoControl = sumaTotal.ToString();
                break;
        }
        return digitoControl.Equals(cif.Substring(8, 1));
    }
    catch (Exception)
    {
        // Cualquier excepción producida, devolverá false. 
        return false;
    }
}

Implementación en Perl

sub validar_cif {
    my $cif = shift;
 
    my ($sociedad, $inscripción, $control) = $cif =~ /^ (.) (\d{7}) (.)/x;
 
    unless ($sociedad and $inscripción and $control) {
        return 'ERROR: No está bien formado';
    }
 
    unless ($sociedad ~~ /[ABCDEFGHJKLMNPRQSUVW]/i) {
        return 'ERROR: La letra inicial del CIF no es correcta';
    }
 
    my @n     = split //, $inscripción;         # separamos los dígitos
 
    my $pares = $n[1] + $n[3] + $n[5];          # sumar los dígitos pares
 
    my $nones;                                  # sumar los dígitos impares
    for (0, 2, 4, 6) {
        my $d   = $n[$_] * 2;                   # los dígitos impares valen doble
        $nones += $d < 10 ? $d : $d - 9;        # ajuste si ese doble es superior a 10
    }
 
    my $c = (10 - substr($pares + $nones, -1))%10;   # dígito de control esperado
 
    my $l = substr('JABCDEFGHI', $c, 1);       # letra de control esperada
 
    given ($sociedad) {                         # según la letra inicial...
 
        when (/[KPQS]/i) {                      # el control debe ser una letra
            if ($l ne uc($control)) {
                return 'ERROR: El CIF no es válido: fallo en la letra de control';
            }
        }
 
        when (/[ABEH]/i) {                      # el control debe ser un número
            if ($c != $control) {
                return 'ERROR: El CIF no es válido: fallo en el dígito de control';
            }
        }
 
        default {                               # puede ser letra o número
            if ($c != $control  and  $l ne uc($control)) {
                return 'ERROR: El CIF no es válido: fallo en el dígito o letra de control';
            }
        }
    }
 
    return 'El CIF es correcto';
}

Implementación en MySQL

CREATE DEFINER = 'root'@'%'
PROCEDURE BBDD.CHECKNIF_ES(IN NIF VARCHAR(20), OUT VALIDO TINYINT)
  COMMENT 'Comprueba la validez de un nif español'
BEGIN
  DECLARE V_NIF   VARCHAR(20) DEFAULT ''; -- Nif sin caracteres inesperados
  DECLARE v1      INT DEFAULT 1; -- Contador para los bucles
  DECLARE aux     VARCHAR(2); -- Auxiliar
  DECLARE BASE_DC VARCHAR(7); -- Dígitos base para el cálculo del dígito de control
  DECLARE DC_A    INTEGER DEFAULT 0; -- Suma de los dígitos pares de BASE_DC
  DECLARE DC_B    INTEGER DEFAULT 0; -- Suma de las cifras de los dobles de los dígitos impares de BASE_DC
  DECLARE DC_C INTEGER DEFAULT 0; -- Suma de DC_A y DC_B
  DECLARE DC_E INTEGER DEFAULT 0; -- Unidades de DC_C
  DECLARE DC_D INTEGER DEFAULT 0;
  DECLARE DC INTEGER DEFAULT 0;
 
  -- Se toma solo la parte del nif dado que se compone de letras y números
  WHILE v1 <= LENGTH(NIF)
  DO
    BEGIN
      SET aux = SUBSTR(NIF, v1,1);
 
      IF ((aux <= '9' AND aux >= '0') OR (aux >= 'a' AND aux <= 'Z')) THEN
        SET V_NIF = CONCAT(V_NIF, aux);
      END IF;
 
      SET v1 = v1 + 1;
    END;
  END WHILE;
 
 
  -- Se comprueba que la longitud sea correcta
  IF (LENGTH(V_NIF) = 9) THEN
    -- Se comprueba que el tipo de entidad sea válido
    IF SUBSTR(V_NIF, 1, 1) IN
    ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'P', 'Q', 'R', 'S', 'U', 'V', 'N', 'W') THEN
      -- Se comprueba que la provincia sea valida
      IF (SUBSTR(V_NIF, 2, 2) > 00 AND SUBSTR(V_NIF, 2, 2) < 65) OR (SUBSTR(V_NIF, 2, 2) > 69 AND SUBSTR(V_NIF, 2, 2) < 85) OR (SUBSTR(V_NIF, 2, 2) > 90 AND SUBSTR(V_NIF, 2, 2) < 99) THEN
        BEGIN
          -- Se comprueba el dígito de control
          SET BASE_DC = SUBSTR(V_NIF, 2, 7);
 
          -- SUMA LAS POSICIONES PARES
          SET DC_A = SUBSTR(BASE_DC, 2, 1) + SUBSTR(BASE_DC, 4, 1) + SUBSTR(BASE_DC, 6, 1);
 
          SET v1 = 1;
 
          -- SUMA LAS POSICIONES IMPARES
          WHILE v1 <= LENGTH(BASE_DC) DO
          BEGIN
            SET aux = SUBSTR(BASE_DC,v1,1);
            SET aux = aux * 2;
            IF(aux < '10') THEN
                SET aux = CONCAT('0',aux);
                END IF;
 
            SET DC_B = DC_B + SUBSTR(aux,1,1) + SUBSTR(aux,2,1);
            SET v1 = v1 + 2;
          END;
          END WHILE;
 
          -- SE SUMAN LOS SUBTOTALES Y SE EXTRAEN LAS UNIDADES
          SET DC_C = DC_A + DC_B;
          SET DC_E = SUBSTR(DC_C,2,1);
 
          IF(DC_E <> '0') THEN
            SET DC_D = 10 - DC_E;
            ELSE SET DC_D = 0;
              END IF;
 
          -- En este caso tiene que ser letra
          IF SUBSTR(V_NIF, 1, 1) IN
          ('K', 'P', 'Q', 'S') THEN
            BEGIN
              /* Restar al dígito + 1 la letra 'A', da un entero 
              que cumple la siguiente correspondencia
 
              A = 1, B = 2, C= 3, D = 4, E = 5, F = 6, G = 7, H = 8, I = 9, J = 10
              */
              IF(SUBSTR(V_NIF, 9, 1)-'A'+1 = DC_D) THEN
                SET VALIDO = 1;
                ELSE SET VALIDO = 0;
              END IF;
              END;
 
          -- En este caso tiene que ser número
          ELSEIF SUBSTR(V_NIF, 1, 1) IN
          ('A', 'B', 'E', 'H') THEN
            BEGIN
              IF(SUBSTR(V_NIF, 9, 1)= DC_D) THEN
                SET VALIDO = 1;
                ELSE SET VALIDO = 0;
              END IF;
            END;
          -- En otro caso puede ser número o letra
          ELSE
            BEGIN
              IF(SUBSTR(V_NIF, 9, 1)= DC_D)OR(SUBSTR(V_NIF, 9, 1)-'A'+1 = DC_D) THEN
                SET VALIDO = 1;
                ELSE SET VALIDO = 0;
              END IF;
            END;
          END IF;
        END;
      ELSE
        SET VALIDO = 0;
      END IF; -- END IF PROVINCIA
 
    ELSE
      SET VALIDO = 0;
    END IF; -- END IF TIPO
  ELSE
    SET VALIDO = 0;
  END IF; -- END IF LONGITUD
END

Abreviaturas de las sociedades [editar]

El CIF debe coincidir con la abreviación final del nombre de la empresa según la siguiente relación: ( listado parcial de Sociedades Civiles y Mercantiles en España )

abreviación	Tipo de sociedad
SL	Sociedad Limitada
SLU	Sociedad Limitada Unipersonal
SLL	Sociedad Limitada Laboral
SLNE	Sociedad Limitada Nueva Empresa
SA	Sociedad Anónima
SAL	Sociedad Anónima Laboral
SAU	Sociedad Anónima Unipersonal
SAE	Sociedad Anónima Española
CB	Comunidad de Bienes
SC	Sociedad Civil
SRL	Sociedad de Responsabilidad Limitada
SCP	Sociedad Civil Particular/Privada
UTE	Unión Temporal de Empresas
COOP	Sociedad Cooperativa
SCA	Sociedad Cooperativa Andaluza
AEIE	Agrupación Europea de Interés Económico
SCI	Sociedad Cooperativa Industrial
AIE	Agrupación de Interés Económico
SCL	Sociedad Cooperativa Limitada
SGR	Sociedad de Garantía Recíproca
SAT	Sociedad Agraria de Transformación
SI	Sociedad Irregular
SAD	Sociedad Anónima Deportiva
SRC	Sociedad Regular Colectiva
SEE	Sucursal en España
SENC	Sociedad en Comandita

Para el código de países extranjeros se usan, a partir del 1 de enero de 1981, los códigos de la Orden de 4 de agosto de 1980,^[4] así como sus diferentes correcciones (BOE NUM. 272, de 12 de noviembre de 1980,^[5] BOE núm. 298, de 12 de diciembre de 1980,^[6] Circular 860/1981, de 30 de junio.^[7] )

Véase también [editar]

Número de identificación fiscal (NIF)
Número de identidad de extranjero (NIE)

Referencias [editar]

Enlaces externos [editar]

Real Decreto 1065/2007, de 27 de julio. (Entrada en vigor el 1 de enero de 2008.)
Buscador de empresas españolas introduciendo su nº CIF
VIES, VAT Information Exchange System, sistema europeo de intercambio de información IVA.

Cálculo del CIF [editar]

Función en PHP para validar los CIF, NIF y NIE.
Otras funciones VBA para validar los CIF, NIF y NIE

[1] BOE núm 49

[2] Decreto 2423/1975

[3] Orden de 3 de julio de 1998

[4] Orden de 4 de agosto de 1980

[5] BOE NUM. 272, de 12 de noviembre de 1980

[6] BOE núm. 298, de 12 de diciembre de 1980

[7] Circular 860/1981, de 30 de junio

[1]

[2]

[3]

[4]

[5]

[6]

[7]

Código de identificación fiscal

Índice

Formato del código [editar]

Rutinas de cálculo [editar]

Abreviaturas de las sociedades [editar]

Véase también [editar]

Referencias [editar]

Enlaces externos [editar]

Cálculo del CIF [editar]

Menú de navegación

Herramientas personales

Espacios de nombres

Variantes

Vistas

Acciones

Buscar

Navegación

Imprimir/exportar

Herramientas

En otros idiomas