Funcao - validar inscricao estadual |
Top Previous Next |
|
// VALIDAR INSCRICAO ESTADUAL
function IEValido(const aUF, aIE, aCGC: string): Boolean; var D1, D2, D3, D4, D5 : LongInt; D6, D7, D8, D9, D10 : LongInt; D11, D12, D13, D14 : LongInt; Tam, X1, X2, X3, DX : LongInt; PriDig, SegDig : LongInt; Veri, P, D : LongInt; IE : string; I : Integer; begin Result := False;
// fica soh numeros IE := ''; for I := 1 to Length(aIE) do if aIE[I] in ['0'..'9'] then IE := IE + aIE[I];
// Se for CPF ou ISENTO é valido if (Length(Trim(aCGC)) = 11) or (Trim(IE) = '') or (Pos('ISENTO', UpperCase(IE)) > 0) then begin Result := True; Exit; end;
// UF não tem 2 caracter é invalido if (Length(aUF) <> 2) then begin Result := False; Exit; end;
Tam := Length(Trim(IE)); /////////////////////////////////////////////////////////////////////////////////// AC { Fórmula do cálculo do dígito verificador da inscrição estadual (módulo 11) Formato: 11 dígitos + 2 dígitos verificadores Os primeiros dois dígitos são sempre 01 Exemplo: Inscrição Estadual 01.004.823/001-12
· Atribui-se um peso a cada dígito, excluindo os dígitos verificadores, seguindo a ordem abaixo: 0 1 0 0 4 8 2 3 0 0 1 4 3 2 9 8 7 6 5 4 3 2 pesos
· Cálculo: (4 x 0) + (3 x 1) + (2 x 0) + (9 x 0) + (8 x 4) + (7 x 8) + (6 x 2) + (5 x 3) + (4 x 0) + (3 x 0) + (2 x 1) = 120
· O resto da divisão entre o resultado da operação acima 120 e o módulo 11 é igual a 10 · Calculamos 11, que é o módulo, menos 10, resultado obtido acima, dá igual a 1 que é o primeiro dígito verificador. Caso a diferença der 10 ou 11, o primeiro dígito é 0. · Atribui-se novamente um peso a cada dígito, incluindo o primeiro dígito verificador calculado acima, seguindo a ordem abaixo:
0 1 0 0 4 8 2 3 0 0 1 1 5 4 3 2 9 8 7 6 5 4 3 2 pesos
· Cálculo: (5 x 0) + (4 x 1) + (3 x 0) + (2 x 0) + (9 x 4) + (8 x 8) + (7 x 2) + (6 x 3) + (5 x 0) + (4 x 0) + (3 x 1) + (2 x 1) = 141
· O resto da divisão entre o resultado da operação acima 141 e o módulo 11 é igual a 9 · Calculamos 11, que é o módulo, menos 9, resultado obtido acima, dá igual a 2 que é o segundo dígito verificador. Caso a diferença der 10 ou 11, o segundo dígito é 0. } if aUF = 'AC' then if (Tam = 13) and (Copy(IE,1,2) = '01') then begin D1 := StrToInt(Copy(IE, 1,1)); D2 := StrToInt(Copy(IE, 2,1)); D3 := StrToInt(Copy(IE, 3,1)); D4 := StrToInt(Copy(IE, 4,1)); D5 := StrToInt(Copy(IE, 5,1)); D6 := StrToInt(Copy(IE, 6,1)); D7 := StrToInt(Copy(IE, 7,1)); D8 := StrToInt(Copy(IE, 8,1)); D9 := StrToInt(Copy(IE, 9,1)); D10 := StrToInt(Copy(IE,10,1)); D11 := StrToInt(Copy(IE,11,1)); D12 := StrToInt(Copy(IE,12,1)); D13 := StrToInt(Copy(IE,13,1));
X1 := (D1*4)+(D2*3)+(D3*2)+(D4*9)+(D5*8)+(D6*7)+(D7*6)+(D8*5)+(D9*4)+(D10*3)+(D11*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; X1 := (D1*5)+(D2*4)+(D3*3)+(D4*2)+(D5*9)+(D6*8)+(D7*7)+(D8*6)+(D9*5)+(D10*4)+(D11*3)+(PriDig*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then SegDig := 0 else SegDig := 11 - X2; if (PriDig = D12) and (SegDig = D13) then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Alagoas { FORMAÇÃO: 24XNNNNND, sendo: 24 – Código do Estado X – Tipo de empresa (0-Normal, 3-Produtor Rural, 5-Substituta, 7- Micro-Empresa Ambulante, 8-Micro-Empresa) NNNNN – Número da empresa D – Dígito de verificação calculado pelo Módulo11, pêsos 2 à 9 da direita para a esquerda, exceto D Exemplo: Número 2 4 0 0 0 0 0 4 D Pesos 9 8 7 6 5 4 3 2 SOMA = (2 * 4) + (3 * 0) + (4 * 0) + (5 * 0) + (6 * 0) + (7 * 0) + (8 * 4) + (9 * 2) = 58 PRODUTO = 58 * 10 = 580 RESTO = 580 – INTEIRO(580 / 11)*11 = 580 – (52*11) = 8 DÍGITO = 8 OBS: Caso RESTO seja igual a 10 o DÍGITO será 0 (zero) } if aUF = 'AL' then if (Tam = 9) and (Copy(IE,1,2) = '24') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 * 10; X3 := X2 - Trunc(X2 div 11) * 11; if (X3 = 10) then PriDig := 0 else PriDig := X3; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Amapá {
Formato: 2 dígitos constantes (03) + 6 dígitos (empresa) +1 dígito verificador
Exemplo: Inscrição Estadual número 030123459
· Verifica-se se os dois primeiros dígitos são de fato 03
· Despreza-se o dígito verificador, trabalhando-se somente com os demais 8 dígitos: 03012345
· Define-se dois valores, p e d, de acordo com as seguintes faixas de Inscrição Estadual: De 03000001 a 03017000 => p = 5 e d = 0 De 03017001 a 03019022 => p = 9 e d = 1 De 03019023 em diante ===>p = 0 e d = 0
No exemplo acima, temos p = 5 e d = 0
· Atribui-se um peso a cada um dos oito dígitos da empresa seguindo a ordem abaixo: 0 3 0 1 2 3 4 5 9 8 7 6 5 4 3 2 pesos
· Cálculo: p + (9 x 0) + (8 x 3) + (7 x 0) + (6 x 1) + (5 x 2) + (4 x 3) + (3 x 4) + (2 x 5) = 79
· O resto da divisão entre o resultado da operação acima 79 e o módulo 11 é igual a 2
· Calculamos 11, que é o módulo, menos 2, resultado obtido acima, e obtemos 9 que é o dígito verificador da Inscrição, que será 030123459, e nesse exemplo estará correta.
· No caso da diferença calculada no item anterior fornecer como resultado 10, o dígito verificador será 0, e se o resultado for 11, ele será d. } if aUF = 'AP' then if (Tam = 9) and (Copy(IE,1,2) = '03') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); Veri := StrToInt(Copy(IE,1,8));
P := 0; D := 0; if (Veri >= 03000001) and (Veri <= 03017000) then begin P := 5; D := 0; end else if (Veri >= 03017001) and (Veri <= 03019022) then begin P := 9; D := 1; end;
X1 := P+(D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; X3 := 11 - X2;
if X3 = 10 then PriDig := 0 else if X3 = 11 then PriDig := D else PriDig := X3;
if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Amazonas { Máscara de edição: 99 . 999 . 999 - 9
dígito verificador Cálculo do dígito verificador: 99 . 999 . 999 hg . fed . cba Soma = (Hx9)+(Gx8)+(Fx7)+(Ex6)+(Dx5)+(Cx4)+(Bx3)+(Ax2) Se Soma < 11 Então Dígito = 11 - Soma Senão Quociente = Soma / 11 Se Resto < ou = 1 Então Dígito = 0 Senão Dígito = 11 - Resto } if aUF = 'AM' then if Tam = 9 then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2);
if X1 < 11 then PriDig := 11 - X1 else begin X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; end; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Bahia { Fórmula do cálculo dos dígitos verificadores da inscrição estadual (módulo 10) O número de inscrição estadual no Cadastro de Contribuintes do Estado da Bahia possui 8 algarismos sendo 6 dígitos inteiros e 2 dígitos verificadores. O Cálculo dos dígitos verificadores é feito através de pesos (2 a 7 para o 2º dígito e 2 a 8 para o 1º dígito). A ordem de cálculo dos dígitos verificadores é feita inicialmente para o 2º dígito. Com o resultado do 2º dígito, faz-se o cálculo do 1º dígito acrescentando-se a este o resultado do 2º dígito.
1. Para Inscrições cujo primeiro dígito da I.E. é 0,1,2,3,4,5,8 cálculo pelo módulo 10
Exemplo: I.E. número 1 2 3 4 5 6 - 6 3
1.1 Cálculo do 2º dígito: Módulo 10 com peso de 2 a 7, aplicados da direita para esquerda, atribuindo um peso a cada dígito da I.E. seguindo a ordem abaixo: 1 2 3 4 5 6 7 6 5 4 3 2 pesos Cálculo: (7 x 1) + (6 x 2) + (5 x 3) + (4 x 4) + (3 x 5) + (2 x 6) = 77
O resto da divisão entre o resultado da operação acima 77 e o módulo 10 é igual a 7 Assim 10 (módulo) - 7 (resto da divisão) = 3 (2º dígito verificador da I.E. 123456-63).
obs.: quando o resto for igual a 0 (zero) o segundo digito é igual a 0 (zero)
1.2 Cálculo do 1º dígito: Módulo 10 com peso de 2 a 8 aplicados da direita para esquerda, repete-se o processo anterior atribuindo um peso a cada dígito da I.E. incluindo o 2º dígito, seguindo a ordem abaixo 1 2 3 4 5 6 3 8 7 6 5 4 3 2 pesos Cálculo: (8 x 1) + (7 x 2) + (6 x 3) + (5 x 4) + (4 x 5) + (3 x 6) + (2 x 3) = 104
O resto da divisão entre o resultado da operação acima 104 e o módulo 10 é igual a 4 Assim 10 (módulo) - 4 (resto da divisão) = 6 (1º dígito verificador da I.E. 123456-63).
2. Para Inscrições cujo primeiro dígito da I.E. é 6, 7 ou 9 cálculo pelo módulo 11
Exemplo: I.E. número 6 1 2 3 4 5 - 5 7
2.1 Cálculo do 2º dígito: Módulo 11 com peso de 2 a 7, aplicados da direita para esquerda, atribuindo um peso a cada dígito da I.E. seguindo a ordem abaixo: 6 1 2 3 4 5 7 6 5 4 3 2 pesos Cálculo: (7 x 6) + (6 x 1) + (5 x 2) + (4 x 3) + (3 x 4) + (2 x 5) = 92
O resto da divisão entre o resultado da operação acima 92 e o módulo 11 é igual a 4 Assim 11 (módulo) - 4 (resto da divisão) = 7 (2º dígito verificador da I.E. 612345-57).
obs.: quando o resto for igual a 0 (zero) ou 1 (um) o segundo digito é igual a 0 (zero)
2.2 Cálculo do 1º dígito: Módulo 11 com peso de 2 a 8 aplicados da direita para esquerda, repete-se o processo anterior atribuindo um peso a cada dígito da I.E. incluindo o 2º dígito, seguindo a ordem abaixo 6 1 2 3 4 5 7 8 7 6 5 4 3 2 pesos Cálculo: (8 x 6) + (7 x 1) + (6 x 2) + (5 x 3) + (4 x 4) + (3 x 5) + (2 x 7) = 127
O resto da divisão entre o resultado da operação acima 127 e o módulo 11 é igual a 6 Assim 11 (módulo) - 6 (resto da divisão) = 5 (1º dígito verificador da I.E. 612345-57).
} if aUF = 'BA' then if Tam = 8 then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1));
if ((D1 >= 0) and (D1 <= 5)) or (D1 = 8) then begin X1 := (D1*7)+(D2*6)+(D3*5)+(D4*4)+(D5*3)+(D6*2); X2 := X1 - Trunc(X1 / 10) * 10; if X2 = 0 then SegDig := 0 else SegDig := 10 - X2; X1 := (D1*8)+(D2*7)+(D3*6)+(D4*5)+(D5*4)+(D6*3)+(SegDig*2); X2 := X1 - Trunc(X1 / 10) * 10; if X2 = 0 then PriDig := 0 else PriDig := 10 - X2; end else begin X1 := (D1*7)+(D2*6)+(D3*5)+(D4*4)+(D5*3)+(D6*2); X2 := X1 - Trunc(X1 / 11) * 11; if (X2 = 0) or (X2 = 1) then SegDig := 0 else SegDig := 11 - X2; X1 := (D1*8)+(D2*7)+(D3*6)+(D4*5)+(D5*4)+(D6*3)+(SegDig*2); X2 := X1 - Trunc(X1 / 11) * 11; if (X2 = 0) or (X2 = 1) then PriDig := 0 else PriDig := 11 - X2; end; if (PriDig = D7) and (SegDig = D8) then Result := True end;
/////////////////////////////////////////////////////////////////////////////////// Ceará, Espirito Sto, Sergipe
///////////////////////// Ceara { Fórmula do cálculo do dígito verificador da inscrição estadual (módulo 11) Formato: 8 dígitos + 1 dígito verificador Exemplo: CGF número 06000001-5 • Atribui-se um peso a cada dígito do CGF seguindo a ordem abaixo: 0 6 0 0 0 0 0 1 9 8 7 6 5 4 3 2 pesos • Cálculo: (9 x 0) + (8 x 6) + (7 x 0) + (6 x 0) + (5 x 0) + (4 x 0) + (3 x 0) + (2 x 1) = 50 • O resto da divisão entre o resultado da operação acima 50 e o módulo 11 é igual a 6 • Pegamos 11, que é o módulo, menos 6, resultado obtido acima, dá igual a 5 que é o dígito verificador do CGF 06000001. Caso a diferença der 10 ou 11, o dígito é 0.
///////////////////////// Espirito Santo INSCRIÇÃO ESTADUAL - DÍGITO VERIFICADOR
MÓDULO 11 - PESO 9
A inscrição estadual é composta de 09 dígitos, sendo o último o verificador.
9 9 9 9 9 9 9 9 0 x x x x x x x x 9 8 7 6 5 4 3 2 81 72 63 54 45 36 27 18 S = 396
Dividir o somatório pelo número 11 Se o resto (R) for menor que 2 Þ o dígito verificador será igual a 0 (zero). Se o resto (R) for maior que 1 Þ o dígito verificador será igual a 11 – R
///////////////////////// Espirito Santo Fórmula do cálculo do dígito verificador da inscrição estadual (módulo 11) Formato: 9 dígitos + 1 dígito verificador Exemplo: IE número 827123456-3
Desconsidera-se, para efeito de cálculo, o primeiro dígito da inscrição e o dígito verificador: No exemplo "827123456-3", o número "27123456" servirá de base para o cálculo Atribui-se um peso a cada dígito da IE, excluindo o dígito verificador, seguindo a ordem abaixo:
2 7 1 2 3 4 5 6 9 8 7 6 5 4 3 2 pesos
Cálculo: (9 x 2) + (8 x 7) + (7 x 1) + (6 x 2) + (5 x 3) + (4 x 4) + (3 x 5) + (2 x 6) = 151;
Divide-se o resultado da operação acima por 11 (módulo 11) e se obtém 8 como resultado; Subtrai-se 11, que é o módulo, de 8, resultado obtido acima, e tem-se 3 como diferença; O resultado da subtração, neste caso 3, será o dígito verificador da IE "827123456"; Caso o número encontrado da subtração seja 10 ou 11, o dígito será 0 (zero). }
if (aUF = 'CE') or (aUF = 'ES') or (aUF = 'SE') then if Tam = 9 then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11;
if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Distrito Federal { Calculo da inscricao estadual para o DF Formato no número: 07 300001 001 - DD | | | | Fixo | | Digitos Verificadores Sequencial | 001-Matriz, 002-Filial, 003-Filial
1-Calculo do 1o. digito verificador Ex: - Multiplicar cada algarismo da inscricao da direita para esquerda pela sequencia 0 7 3 0 0 0 0 1 0 0 1 x 4 3 2 9 8 7 6 5 4 3 2 ------------------------------- 0 21 6 0 0 0 0 5 0 0 2
- Somar os algarismos do resultado 0+21+6+0+0+0+0+5+0+0+2 = 34
- Dividir o resultado por 11 34 |11 --------- 1 3
- Subtrair 11 do resto da divisao 11 - 1 = 10
- O resultado obtido será o primeiro digito verificador. - Se o resultado for igual a 10 ou 11 o primeiro digito verificador sera igual a 0 (zero).
2-Calculo do 2o. digito verificador Ex: - Multiplicar cada algarismo da inscricao da direita para esquerda pela sequencia 0 7 3 0 0 0 0 1 0 0 1 - 0 x 5 4 3 2 9 8 7 6 5 4 3 2 ----------------------------------- 0 28 9 0 0 0 0 6 0 0 3 0
- Somar os algarismos do resultado 0+28+9+0+0+0+0+6+0+0+3+0 = 46
- Dividir o resultado por 11 46 |11 --------- 2 4
- Subtrair 11 do resto da divisao 11 - 2 = 9
- O resultado obtido será o primeiro digito verificador. - Se o resultado for igual a 10 ou 11 o primeiro digito verificador sera igual a 0 (zero).
Resultado 07 300001 001 - 09
} if aUF = 'DF' then if (Tam = 13) and (Copy(IE,1,2) = '07') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); D11 := StrToInt(Copy(IE,11,1)); D12 := StrToInt(Copy(IE,12,1)); D13 := StrToInt(Copy(IE,13,1)); X1 := (D1*4)+(D2*3)+(D3*2)+(D4*9)+(D5*8)+(D6*7)+(D7*6)+(D8*5)+(D9*4)+(D10*3)+(D11*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; X1 := (D1*5)+(D2*4)+(D3*3)+(D4*2)+(D5*9)+(D6*8)+(D7*7)+(D8*6)+(D9*5)+(D10*4)+(D11*3)+(PriDig*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then SegDig := 0 else SegDig := 11 - X2; if (PriDig = D12) and (SegDig = D13) then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Goiás { Fórmula do cálculo do dígito verificador da inscrição estadual
Formato da Inscrição: AB.CDE.FGH-I 8 dígitos (ABCDEFGH) + 1 dígito verificador (I); onde AB pode ser igual a 10 ou 11 ou 15.
CCE de Exemplo: 10.987.654-7
-Atribui-se um peso a cada dígito do CCE seguindo a ordem abaixo:
CCE = 1 0 9 8 7 6 5 4 PESOS = 9 8 7 6 5 4 3 2
Cálculo: (9x1)+(8x0)+(7x9)+(6x8)+(5x7)+(4x6)+(3x5)+(2x4) = 202
- Divide-se 202 por 11 = 18 e sobra 4 (resto) - Quando a inscrição for 11094402 o dígito verificador pode ser zero (0) e pode ser um (1); - Quando o resto da divisão for zero (0), o dígito verificador será zero (0); - Quando o resto da divisão for um (1), e a inscrição for maior ou igual a 10103105 e menor ou igual a 10119997, o dígito verificador será um (1); - Quando o resto da divisão for um (1), e a inscrição estiver fora do intervalo citado acima, o dígito verificador será zero (0); - Quando o resto for diferente de um (1) ou zero (0), o dígito verificador será onze (11) menos o resto. No exemplo acima onze (11) menos quatro (4) é igual a sete (7) que é o dígito verificador da Inscrição 10.987.654-7 } if aUF = 'GO' then if (Tam = 9) and ((Copy(IE,1,2) = '10') or (Copy(IE,1,2) = '11') or (Copy(IE,1,2) = '15')) then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); Veri := StrToInt(Copy(IE,1,8)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 >= 2 then PriDig := 11 - X2 else begin if X2 = 0 then PriDig := 0 else begin if (X2 = 1) and ((Veri >= 10103105) and (Veri <= 10119997)) then PriDig := 1 else PriDig := 0; end; end;
if (Veri = 11094402) and ((D9 = 1) or (D9 = 0)) then Result := True else if PriDig = D9 then Result := True end;
/////////////////////////////////////////////////////////////////////////////////// Maranhão { Formato: numérico
Tamanho: 9 dígitos, sendo: ...........- os dois primeiros correspondentes ao código do Estado(12); ...........- os seis seguintes ao número de ordem no cadastro; ...........- e o último dígito ao dígito de controle, calculado através do módulo 11. Exemplo: calcular o dígito verificador X do número de inscrição estadual 12000038X Passo 1: Multiplica um peso, já definido abaixo, pelo dígito equivalente do número de inscrição: .....Nº de Inscrição fornecido .......1.....2.....0.....0.....0.....0.....3.....8.....X ...............Peso p/Multiplicar .......9.....8.....7.....6.....5.....4.....3.....2.....DV
Passo 2: Soma-se o resultado das multiplicações acima e divide-se por 11. Soma = (9x1) + (8x2) + (7x0) + (6x0) + (5x0) + (4x0) + (3x3) + (2x8) = 50
Passo 3: Se o resto da divisão é 0 ou 1, o dígito é 0. Caso contrário, o dígito é 11 - resto da divisão. ................50 dividido por 11 = 4 ................Resto = 6 ................Dígito Verificador = 11 - 6 = 5 Inscrição Estadual com dígito verificador: 120000385
} if aUF = 'MA' then if (Tam = 9) and (Copy(IE,1,2) = '12') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Mato Grosso { Este procedimento poderá ser implementado nos aplicativos que se utilizam do número da Inscrição Estadual, evitando desta forma que sejam informados números incorretos. • FORMATO : NNNNNNNNNN-D • CONSISTÊNCIA: Cálculo do Dígito Verificador - Módulo 11 (2 a 9, 2 a 9) • Exemplo: 0013000001-9 0 0 1 3 0 0 0 0 0 1 3 2 9 8 7 6 5 4 3 2 (Pesos) (3 x 0 + 2 x 0 + 9 x 1 + 8 x 3 + 7 x 0 + 6 x 0 + 5 x 0 + 4 x 0 + 3 x 0 + 2 x 1) = 35 35 : 11 = Resto 2 => 11 - 2 = 9 DV=9 OBS.: Se o resto da divisão for (0) zero ou (1) um DV=0. } if aUF = 'MT' then begin if Tam <> 11 then IE := AlinhaDir(IE,11,'0'); D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); D11 := StrToInt(Copy(IE,11,1)); X1 := (D1*3)+(D2*2)+(D3*9)+(D4*8)+(D5*7)+(D6*6)+(D7*5)+(D8*4)+(D9*3)+(D10*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D11 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Mato Grosso Sul { O método adotado para se verificar a compatibilidade entre o número principal da inscrição estadual, composto dos primeiros oito dígitos, e o seu dígito verificador, representado pelo nono dígito, segue as regras:
I – o primeiro dígito será sempre representado pelo número 2; II - o segundo dígito será sempre representado pelo número 8.
O método a que se refere o artigo anterior é assim representado:
A = (1º x 9)+(2º x 8)+(3º x 7)+(4º x 6)+(5º x 5)+(6º x 4)+(7º x 3)+(8º x 2) R = Resto de A/11 Se R = 0, então D = 0 Se R > 0 T = 11 – R Se T > 9, então D = 0 Se T < 10, então D = T
Em que D = Dígito Verificador.
} if aUF = 'MS' then if (Tam = 9) and (Copy(IE,1,2) = '28') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Pará { CÁLCULO DA INSCRIÇÃO ESTADUAL - SEFA - PARÁ
Tamanho:9 Formato: Numérico Composição: 15-999999-5
15: Número Padrão Pará
999999: Sequência
5: Dígito Verificador (Módulo 11)
Cálculo do dígito verificador Módulo 11
1- Multiplica-se os números, da direita para a esquerda, pelos seguintes valores: 2, 3, 4, 5, 6, 7, 8, 9;
2- Soma-se os resultados intermediários e divide-se por 11;
3- Se o resto da divisão é 0 ou 1, o dígito é 0;
4- Se o resto da divisão não é 0 nem 1, o dígito é = 11 - resto da divisão;
Exemplo: Cálculo para a Inscrição 15999999-5
9 x 1 = 9 8 x 5 = 40 7 x 9 = 63 6 x 9 = 54 5 x 9 = 45 4 x 9 = 36 3 x 9 = 27 2 x 9 = 18 292
292 : 11 = 26 (Resto 6) 11 - 6 = 5 (Dígito Verificador 5)
} if aUF = 'PA' then if (Tam = 9) and (Copy(IE,1,2) = '15') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D9 then Result := True end;
/////////////////////////////////////////////////////////////////////////////////// Paraiba { Fórmula do cálculo do dígito verificador da inscrição estadual (módulo 11)
Formato: 8 dígitos + 1 dígito verificador
Exemplo: CGF número 06000001-5
Atribui-se um peso a cada dígito do CGF seguindo a ordem abaixo:
0 6 0 0 0 0 0 1 9 8 7 6 5 4 3 2 pesos
Cálculo:
(9 x 0) + (8 x 6) + (7 x 0) + (6 x 0) +
(5 x 0) + (4 x 0) + (3 x 0) + (2 x 1) = 50
O resto da divisão entre o resultado da operação acima 50 e o módulo 11 é igual a 6
Pegamos 11, que é o módulo, menos 6, resultado obtido acima, dá igual a 5 que é o dígito verificador do CGF 06000001. Caso a diferença der 10 ou 11, o dígito é 0. } if aUF = 'PB' then if (Tam = 9) and (Copy(IE,1,2) = '16') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Paraná { Formato da Inscrição: NNNNNNNN-DD Cálculo do Primeiro Dígito: Módulo 11 com pesos de 2 a 7, aplicados da direita para esquerda, sobre as 8 primeiras posições. Cálculo do Segundo Dígito: Módulo 11 com pesos de 2 a 7, aplicados da direita para esquerda, sobre as 9 primeiras posições (inclui o primeiro dígito).
1º Passo: Multiplicar, da direita para esquerda, cada algarismo por pesos de 2 a 7, respectivamente, somar os resultados, calcular o módulo 11 e subtrair de 11. Se resto for 1 u 0, veja observação abaixo.
1 2 3 4 5 6 7 8 (CAD) 3 2 7 6 5 4 3 2 (pesos)
=> 8x2 + 7x3 + 6x4 + 5x5 + 4x6 + 3x7 + 2x2 + 1x3
=> 16+ 21 + 24 + 25 + 24 + 21 + 4 + 3 = 138
Cálculo de módulo 11 (resto da divisão por 11)
138 / 11 = 12 => resto 6 (módulo11)
11 - 6 = 5 (1º dígito verificador)
2º Passo: Acrescentar o 1º dígito calculado ao CAD.
123.45678-5
3º Passo: Repetir 2º passo ao CAD do 3º passo.
1 2 3 4 5 6 7 8 5 (CAD) 4 3 2 7 6 5 4 3 2 (pesos)
=> 5x2 + 8x3 + 7x4 + 6x5 + 5x6 + 4x7 + 3x2 + 2x3 1x4
=> 10 + 24 + 28 + 30 + 30 + 28 + 6 + 6 + 4 = 166
Cálculo de módulo 11 (resto da divisão por 11)
166 / 11 = 15 => resto 1 (módulo 11)
11 - 1 = 10
Obs: Como cada dígito significa um algarismo, no caso do resto ser 1 ou 0, gerando "dígitos" 10 e 11, definimos o dígito como sendo 0.
4º Passo: Reslutado final - CAD 123.45678-50 } if aUF = 'PR' then if Tam = 10 then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); X1 := (D1*3)+(D2*2)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; X1 := (D1*4)+(D2*3)+(D3*2)+(D4*7)+(D5*6)+(D6*5)+(D7*4)+(D8*3)+(PriDig*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then SegDig := 0 else SegDig := 11 - X2; if (PriDig = D9) and (SegDig = D10) then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Pernabuco { Dígito Verificador da Inscrição Estadual
O número de inscrição estadual no Cadastro de Contribuintes do Estado de Pernambuco - CACEPE possui 14 algarismos (dígitos), sendo 13 principais e 1 verificador. O cálculo do dígito verificador envolve o uso de "pesos" e da função "módulo" com parâmetro "11", conforme pode ser visto no exemplo abaixo:
Procedimentos de Cálculo (ex. para 18.1.001.0000004-9) 1. Multiplique cada algarismo principal pelo seu respectivo peso: 1 8 1 0 0 1 0 0 0 0 0 0 4 (algarismos) x x x x x x x x x x x x x 5 4 3 2 1 9 8 7 6 5 4 3 2 (pesos) = = = = = = = = = = = = = 5 32 3 0 0 9 0 0 0 0 0 0 8 (produtos) 2. Some os produtos obtidos para encontrar o total: 5 + 32 + 3 + 0 + 0 + 9 + 0 + 0 + 0 + 0 + 0 + 0 + 8 = 57 (total dos produtos) 3. Divida esse total pela constante "11" para obter o resto: cacepe1.gif (1181 bytes) 4. Subtraia esse resto da constante "11" para encontrar o dígito verificador: 11 - 2 = 9 Quando essa diferença for maior que "9", subtraia "10" unidades para obter o valor do dígito verificador, uma vez que o mesmo deve ser sempre representado por apenas um algarismo. } if aUF = 'PE' then if (Tam = 14) and (Copy(IE,1,2) = '18') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); D11 := StrToInt(Copy(IE,11,1)); D12 := StrToInt(Copy(IE,12,1)); D13 := StrToInt(Copy(IE,13,1)); D14 := StrToInt(Copy(IE,14,1)); X1 := (D1*5)+(D2*4)+(D3*3)+(D4*2)+(D5*1)+(D6*9)+(D7*8)+(D8*7)+(D9*6)+(D10*5)+(D11*4)+(D12*3)+(D13*2); X2 := X1 - Trunc(X1 / 11) * 11; PriDig := 11 - X2; if PriDig >= 10 then PriDig := PriDig - 10; if PriDig = D14 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Piauí { Fórmula do cálculo do dígito verificador da inscrição estadual
Formato: 8 dígitos (empresa) +1 dígito verificador
Exemplo: Inscrição Estadual número 012345679
· Despreza-se o dígito verificador, trabalhando-se somente com os demais 8 dígitos: 01234567 · Atribui-se um peso a cada um dos oito dígitos seguindo a ordem abaixo:
0 1 2 3 4 5 6 7 9 8 7 6 5 4 3 2 pesos
· Cálculo
(9 x 0) + (8 x 1) + (7 x 2) + (6 x 3) + (5 x 4) + (4 x 5) + (3 x 6) + (2 x 7) = 112
· O resto da divisão entre o resultado da operação acima 112 e o módulo 11 é igual a 2 · Calculamos 11, que é o módulo, menos 2, resultado obtido acima, e obtemos 9 que é o dígito verificador da Inscrição, que ficará 012345679, e nesse exemplo ela está correta. · No caso da diferença calculada no item anterior fornecer como resultado 10 ou 11, o dígito verificador será 0. } if aUF = 'PI' then if (Tam = 9) and (Copy(IE,1,2) = '19') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Rio de Janeiro { FORMATO 99.999.99-3
N1 N2 N3 N4 N5 N6 N7 9 9 . 9 9 9 . 9 9
[(N1 x 2) + (N2 x 7) + (N3 x 6) + (N4 x 5) + (N5 x 4) + (N6 x 3) + (N7 x 2) + ] / 11
- Se o resto da divisão por 11 for menor ou igual à 1 (um), - Então o dígito verificador será = 0 (zero) - Senão, o dígito será 11 (onze) menos o resto } if aUF = 'RJ' then if Tam = 8 then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); X1 := (D1*2)+(D2*7)+(D3*6)+(D4*5)+(D5*4)+(D6*3)+(D7*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D8 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Rio Grande do Norte { INSCRIÇÃO : 20.040.040-1
MEMÓRIA DE CÁLCULO:
2 * 9 = 18 0 * 8 = 0 0 * 7 = 0 4 * 6 = 24 0 * 5 = 0 0 * 4 = 0 4 * 3 = 12 0 * 2 = 0 ......---- SOMA -> 54 MULTIPLICA A SOMA POR 10 .....MULTIPLICAÇÃO = SOMA * 10 = 54 * 10 = 540 DIVIDE POR 11, OBTENDO O RESTO DA DIVISÃO .....DIVISÃO = MULTIPLICAÇÃO / 11 = 540 / 11 ...............RESTO (DIVISÃO) = 1 DIGITO VERIFICADOR = RESTO (DIVISÃO) OBSERVAÇÃO: CASO O DÍGITO CALCULADO SEJA 10, CONSIDERAR DÍGITO = 0 } if aUF = 'RN' then if (Tam = 9) and (Copy(IE,1,2) = '20') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 * 10; X3 := X2 - Trunc(X2 / 11) * 11; if X3 = 10 then PriDig := 0 else PriDig := X3; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Rio Grande do Sul { Formato: 3 dígitos (município) + 6 dígitos (empresa) + 1 dígito verificador
Exemplo: Inscrição Estadual número 224/3658792
· Despreza-se o dígito verificador, trabalhando-se somente com os demais 9 dígitos: 224365879 · Atribui-se um peso a cada um dos nove dígitos seguindo a ordem abaixo: 2 2 4 3 6 5 8 7 9 2 9 8 7 6 5 4 3 2 pesos
· Cálculo
(2 x 2) + (9 x 2) + (8 x 4) + (7 x 3) + (6 x 6) + (5 x 5) + (4 x 8) + (3 x 7) + (2 x 9) = 207
· O resto da divisão entre o resultado da operação acima 207 e o módulo 11 é igual a 9 · Calculamos 11, que é o módulo, menos 9, resultado obtido acima, e obtemos 2 que é o dígito verificador da Inscrição, que ficará 224365879, e nesse exemplo ela está correta. · No caso da diferença calculada no item anterior fornecer como resultado 10 ou 11, o dígito verificador será 0. } if aUF = 'RS' then if (Tam = 10) and (StrToInt(Copy(IE,1,1)) <= 4) then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); X1 := (D1*2)+(D2*9)+(D3*8)+(D4*7)+(D5*6)+(D6*5)+(D7*4)+(D8*3)+(D9*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D10 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Rondonia { Fórmula do cálculo do dígito verificador da inscrição estadual
1. Fórmula adotada antes de 01/08/2000 Formato: 3 dígitos (município) + 5 dígitos (empresa) +1 dígito verificador
Exemplo: Inscrição Estadual número 101.62521-3
· Despreza-se os três primeiros dígitos (101 nesse caso, indicando Porto Velho), assim como o dígito verificador, trabalhando-se somente com os cinco dígitos indicadores da empresa: 62521 · Atribui-se um peso a cada um dos cinco dígitos da empresa seguindo a ordem abaixo: 6 2 5 2 1 6 5 4 3 2 pesos
· Cálculo: (6 x 6) + (5 x 2) + (4 x 5) + (3 x 2) + (2 x 1) = 74
· O resto da divisão entre o resultado da operação acima 74 e o módulo 11 é igual a 8 · Calculamos 11, que é o módulo, menos 8, resultado obtido acima, dá igual a 3 que é o dígito verificador da Inscrição 101.62521 · No caso da diferença calculada no parágrafo anterior fornecer como resultado 10 ou 11, subtrai-se 10 da mesma para obter o dígito verificador.
2. Fórmula adotada a partir de 01/08/2000 Formato: 13 dígitos (empresa) + 1 dígito verificador
O código de município não faz mais parte da Inscrição Estadual.
2.1 As empresas existentes antes de 31/07/2000 terão sua Inscrição Estadual alterada da seguinte forma:
* Retira-se o código de município; * Acrescenta-se zeros à esquerda aos antigos 5 dígitos identificadores da empresa, até chegar a 13 dígitos; * Conserva-se o dígito verificador antigo, que continua sendo válido na nova fórmula.
Exemplo: Inscrição Estadual anterior número 101.62521-3, passa a ser 0000000062521-3.
2.2 As Inscrições Estaduais concedidas a partir de 24/07/2000 já estão sendo feitas de acordo com a nova fórmula.
2.3 Rotina de cálculo com a nova fórmula
Exemplo: Inscrição Estadual 0000000062521-3
· Despreza-se o dígito verificador, trabalhando-se somente com os treze dígitos indicadores da empresa: 0000000062521 · Atribui-se um peso a cada um dos treze dígitos da empresa seguindo a ordem abaixo: 0 0 0 0 0 0 0 0 6 2 5 2 1 6 5 4 3 2 9 8 7 6 5 4 3 2 pesos
· Cálculo: (6 x 0) + (5 x 0) + (4 x 0) + (3 x 0) + (2 x 0) + (9 x 0) + (8 x 0) + (7 x 0) + (6 x 6) + (5 x 2) + (4 x 5) + (3 x 2) + (2 x 1) = 74
O restante dos procedimentos são idênticos aos utilizados anteriormente:
· O resto da divisão entre o resultado da operação acima 74 e o módulo 11 é igual a 8 · Calculamos 11, que é o módulo, menos 8, resultado obtido acima, dá igual a 3 que é o dígito verificador da Inscrição 0000000062521 · No caso da diferença calculada no parágrafo anterior fornecer como resultado 10 ou 11, subtrai-se 10 da mesma para obter o dígito verificador. } if aUF = 'RO' then if Tam = 14 then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); D11 := StrToInt(Copy(IE,11,1)); D12 := StrToInt(Copy(IE,12,1)); D13 := StrToInt(Copy(IE,13,1)); D14 := StrToInt(Copy(IE,14,1)); X1 := (D1*6)+(D2*5)+(D3*4)+(D4*3)+(D5*2)+(D6*9)+(D7*8)+(D8*7)+(D9*6)+(D10*5)+(D11*4)+(D12*3)+(D13*2); X2 := X1 - Trunc(X1 / 11) * 11; PriDig := 11 - X2; if PriDig >= 10 then PriDig := PriDig - 10; if PriDig = D14 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Roraima { O Número de Inscrição Estadual é composto por 9 Dígitos, sendo os dois primeiros indicativos do Estado da Federação, 6 dígitos que representam a inscrição e, por último, um Dígito Verificador de módulo 9. Algumas inscrições com dígito válido: 24006628-1 24001755-6 24003429-0 24001360-3 24008266-8 24006153-6 24007356-2 24005467-4 24004145-5 24001340-7
Exemplo: inscrição (240061536)
12345678 => posição dos dígitos do número 240061536 => número da inscrição
Multiplicar o número referente à posição pelo número referente à inscrição ex: 1*2, 2*4, 3*0 etc, somando os valores, ao final o dígito verificador será o resto da divisão deste número por (9). Neste exemplo temos a soma de (105) e o resto da divisão deste valor por (9) dá (6) que é o dígito da inscrição. } if aUF = 'RR' then if (Tam = 9) and (Copy(IE,1,2) = '24') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*1)+(D2*2)+(D3*3)+(D4*4)+(D5*5)+(D6*6)+(D7*7)+(D8*8); X2 := X1 - Trunc(X1 / 9) * 9; if X2 = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Sta Catarina { Exemplo: inscrição 251.040.852 # Atribui-se um peso a cada dígito da inscrição exceto o ultimo digito a esquerda
2 5 1 0 4 0 8 5 (inscrição) 9 8 7 6 5 4 3 2 (pesos)
Cálculo:
(9 x 2) + (8 x 5) + (7 x 1) + (6 x 0) + (5 x 4) + (4 x 0) + (3 x 8) + (2 x 5) = 119
Divida o resultado por 11: 119 / 11 = 10 tendo o resto da divisão igual a 9 Subtraia o resto da divisão (9) de 11 para obter o digito verificador: 11 – 9 = 2 Obs: Quando o resto da divisão for zero (0) ou um (1), o digito será zero (0). } if aUF = 'SC' then if (Tam = 9) and (Copy(IE,1,2) = '25') then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); X1 := (D1*9)+(D2*8)+(D3*7)+(D4*6)+(D5*5)+(D6*4)+(D7*3)+(D8*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D9 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Sao Paulo { Fórmula do cálculo do dígito verificador da inscrição estadual (módulo 11)
Regra Geral: Em todas as contagens de posições de caracteres e cálculos efetuados deverão ser ignorados caracteres diferentes da letra "P" e dos algarismos 0, 1, 2, 3, 4, 5, 6, ,7, 8 e 9.
I – Industriais e comerciantes (exceto produtores rurais a eles não equiparados):
à Formato: 12 dígitos sendo que o 9º e o 12º são dígitos verificadores à Exemplo: Inscrição Estadual 110.042.490.114
a) Cálculo do 1º dígito verificador, ou seja, do 9º dígito contado a partir da esquerda:
- Atribui-se um peso a cada dígito da Inscrição Estadual seguindo a ordem utilizada abaixo:
1 1 0 0 4 2 4 9 0 1 1 4 1 3 4 5 6 7 8 10 PESOS (1 x 1) + (1 x 3) + (0 x 4) + (0 x 5) + (4 x 6) + (2 x 7) + (4 x 8) + (9 x 10) = 1 + 3 + 0 + 0 + 24 + 14 + 32 + 90 = 164
- O dígito verificador será o algarismo mais à direita do resto da divisão do resultado obtido acima (164) por 11
à 164/11 = 14 com resto = 10, então o 1º dígito verificador (9ª posição) é 0
b) Cálculo do 2º dígito verificador, ou seja, do 12º dígito contado a partir da esquerda:
* Atribui-se um peso a cada dígito da Inscrição Estadual seguindo a ordem utilizada abaixo:
1 1 0 0 4 2 4 9 0 1 1 4 3 2 10 9 8 7 6 5 4 3 2 PESOS
(1 x 3) + (1 x 2) + (0 x 10) + (0 x 9) + (4 x 8) + (2 x 7) + (4 x 6) + (9 x 5) + (0 x 4) + (1 x 3) + (1 x 2) = 3 + 2 + 0 + 0 + 32 + 14 + 24 + 45 + 0 + 3 + 2 = 125
O dígito verificador será o algarismo mais à direita do resto da divisão do resultado obtido acima (118) por 11 à 125/11 = 11 com resto = 4, então o 2º dígito verificador (12ª posição) é 4
Fica então formada a inscrição 110.042.490.114
II – Inscrição estadual de Produtor Rural (Não equiparado a industrial ou comerciante, cujas inscrições obedecem a Regra descrita no item anterior):
à Formato: - P0MMMSSSSD000 - 13 caracteres dos quais o 10º caracter contado a partir da esquerda ("D") é o dígito verificador
- Inicia sempre com "P" e apresenta a sequência 0MMMSSSSD000, onde:
0MMMSSSS à algarismos que serão utilizados no cálculo do dígito verificador "D" "D" à Dígito verificador que consiste os 8 (oito)dígitos imediatamente anteriores 000 à 3 (três) dígitos que compõem o nº de inscrição mas não utilizados no cálculo do dígito verificador
à Exemplo: Inscrição Estadual P-01100424.3/002
Cálculo do dígito verificador, ou seja, do 10º dígito contado a partir da esquerda, incluindo-se na contagem a letra "P":
- Atribui-se um peso a cada dígito da Inscrição Estadual a partir do primeiro 0 (zero) seguindo a ordem utilizada abaixo:
0 1 1 0 0 4 2 4 3 1 3 4 5 6 7 8 10 PESOS
(0x 1) + (1 x 3) + (1 x 4) + (0 x 5) + (0 x 6) + (4 x 7) + (2 x 8) + (4 x 10) = 0 + 3 + 4 + 0 + 0 + 28 + 16 + 40 = 91
- O dígito verificador será o algarismo mais à direita do resto da divisão do resultado obtido acima (91) por 11
à 91/11 = 8 com resto = 3, então o dígito verificador (10ª posição) é 3
Fica então formada a inscrição P-011000424.3/002 } if aUF = 'SP' then if (Tam = 12) or ((Tam = 13) and (Copy(IE,1,1) = 'P')) then begin D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); D11 := StrToInt(Copy(IE,11,1)); D12 := StrToInt(Copy(IE,12,1)); // D13 := StrToInt(Copy(IE,13,1));
if (Tam = 13) and (Copy(IE,1,1) = 'P') then begin X1 := (D2*1)+(D3*3)+(D4*4)+(D5*5)+(D6*6)+(D7*7)+(D8*8)+(D9*10); X2 := X1 - Trunc(X1 / 11) * 11; PriDig := X2; if PriDig = 10 then PriDig := 0; if PriDig = D10 then Result := True; end else begin D1 := StrToInt(Copy(IE,1,1)); X1 := (D1*1)+(D2*3)+(D3*4)+(D4*5)+(D5*6)+(D6*7)+(D7*8)+(D8*10); X2 := X1 - Trunc(X1 / 11) * 11; PriDig := X2; if PriDig = 10 then PriDig := 0; X1 := (D1*3)+(D2*2)+(D3*10)+(D4*9)+(D5*8)+(D6*7)+(D7*6)+(D8*5)+(PriDig*4)+(D10*3)+(D11*2); X2 := X1 - Trunc(X1 / 11) * 11; SegDig := X2; if SegDig = 10 then SegDig := 0; if (PriDig = D9) and (SegDig = D12) then Result := True; end; end;
/////////////////////////////////////////////////////////////////////////////////// Tocantins { Cálculo da Inscrição Estadual
Aplica-se o cálculo "módulo 11" com os algarismos 1,2,5,6,7,8,9,10 da Inscrição Estadual, criando o "11º" que é o dígito verificador. Os dígitos "3" e "4" não entram no cálculo, porém podem assumir somente os seguintes valores:
01 = Produtor Rural ( não possui CGC) 02 = Industria e Comércio 03 = Empresas Rudimentares 99 = Empresas do Cadastro Antigo (SUSPENSAS)
Exemplo: 29 01 022783 6
2 9 0 1 0 2 2 7 8 3
9 8 7 6 5 4 3 2
- SOMA I = ( ( PRIMEIRO * 9) + (SEGUNDO * 8) + (TERCEIRO * 7) + (QUARTO * 6) + (QUINTO * 5) + (SEXTO * 4) + (SÉTIMO * 3) + (OITAVO * 2) ) - DIVISÃO MODAL DA "SOMA I" POR "ONZE" - SE O RESTO DA DIVISÃO FOR MENOR QUE DOIS DÍGITO = ZERO. - OU SE O RESTO DA DIVISÃO FOR MAIOR OU IGUAL A DOIS DÍGITO = ONZE MENOS O RESTO NO EXEMPLO: 170 = (2 * 9) + (9 * 8) + (0 * 7) + (2 * 6) + (2 * 5) + (7 * 4) + (8 * 3) + (3 * 2) 170 / 11 = 15 -----» resto = 5 (pois 15 x 11 = 165) 5 > 2 portanto DÍGITO = 11 - 5 OU SEJA DÍGITO = 6 } if aUF = 'TO' then if (Tam = 11) and (Copy(IE,1,2) = '29') and ((Copy(IE,3,2) = '01') or (Copy(IE,3,2) = '02') or (Copy(IE,3,2) = '03') or (Copy(IE,3,2) = '99')) then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); // D3 := StrToInt(Copy(IE,3,1)); // D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); D11 := StrToInt(Copy(IE,11,1)); X1 := (D1*9)+(D2*8)+(D5*7)+(D6*6)+(D7*5)+(D8*4)+(D9*3)+(D10*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then PriDig := 0 else PriDig := 11 - X2; if PriDig = D11 then Result := True; end;
/////////////////////////////////////////////////////////////////////////////////// Minas if aUF = 'MG' then if Tam = 13 then begin D1 := StrToInt(Copy(IE,1,1)); D2 := StrToInt(Copy(IE,2,1)); D3 := StrToInt(Copy(IE,3,1)); D4 := StrToInt(Copy(IE,4,1)); D5 := StrToInt(Copy(IE,5,1)); D6 := StrToInt(Copy(IE,6,1)); D7 := StrToInt(Copy(IE,7,1)); D8 := StrToInt(Copy(IE,8,1)); D9 := StrToInt(Copy(IE,9,1)); D10 := StrToInt(Copy(IE,10,1)); D11 := StrToInt(Copy(IE,11,1)); D12 := StrToInt(Copy(IE,12,1)); D13 := StrToInt(Copy(IE,13,1));
X1 := D1+D3+D4+D6+D8+D10; DX := D2 * 2;
if DX < 9 then X1 := X1 + DX else if DX = 10 then X1 := X1 + 1 else begin X1 := X1 + 1; X1 := X1 + (DX - 10); end;
DX := D5 * 2; if DX < 9 then X1 := X1 + DX else if DX = 10 then X1 := X1 + 1 else begin X1 := X1 + 1; X1 := X1 + (DX - 10); end;
DX := D7 * 2; if DX < 9 then X1 := X1 + DX else if DX = 10 then X1 := X1 + 1 else begin X1 := X1 + 1; X1 := X1 + (DX - 10); end;
DX := D9 * 2; if DX < 9 then X1 := X1 + DX else if DX = 10 then X1 := X1 + 1 else begin X1 := X1 + 1; X1 := X1 + (DX - 10); end;
DX := D11 * 2; if DX < 9 then X1 := X1 + DX else if DX = 10 then X1 := X1 + 1 else begin X1 := X1 + 1; X1 := X1 + (DX - 10); end;
X2 := X1 - Trunc(X1 / 10) * 10; PriDig := 10 - X2; if PriDig = 10 then PriDig := 0; X1 := (D1*3)+(D2*2)+(D3*11)+(D4*10)+(D5*9)+(D6*8)+(D7*7)+(D8*6)+(D9*5)+(D10*4)+(D11*3)+(PriDig*2); X2 := X1 - Trunc(X1 / 11) * 11; if X2 <= 1 then SegDig := 0 else SegDig := 11 - X2; if (PriDig = D12) and (SegDig = D13) then Result := True; end; end; |