Para validar podemos recorrer a dll do sintegra (DLL3.zip) que é apenas 32 bits, mas se precisarmos de uma biblioteca 64 bits ou quando queremos gerar dados em massa para testes? Geradores online podem funcionar bem para testes únicos, ou individuais, mas para testes automatizados ou geração de arquivos é bom ter o código fonte, ou uma dll compatível com C, tanto x86 quanto x64. A referência geral dos cálculos pode ser encontrada em: http://www.sintegra.gov.br/insc_est.html. Já que pela internet achei basicamente códigos em Pascal ou Basic, segue o código fonte dos geradores de inscrição estadual em linguagens mais portáteis por assim dizer. Eu também criei um gerador para Firefox que cria números com um clique apenas.
Vou postando a lista a medida que converter os códigos, mas basicamente até agora, a lógica é basicamente a mesma. Alteramos apenas o comprimento de cada formato, e a sequência de números pelos quais multiplicamos para obter os dígitos verificadores.
O documento com a definição da estrutura da inscrição estadual do Acre e dígitos verificadores pode ser encontrado em: http://www.sintegra.gov.br/Cad_Estados/cad_AC.html ou http://apl03.sefaz.al.gov.br/sintegra/sintegra/cad_AC.asp
Números de inscrição estadual do Acre fáceis de lembrar são: ?? e ??.
Rust Gerador
Rust Validador
C++ Gerador
C++ Validador
C# Gerador
C# Validador
public bool ValidarInscricaoEstadualAcre(string inscricaoEstadual) {
if (inscricaoEstadual.Substring(0, 2) != "01") {
return false;
}
return ValidarInscricaoEstadualModulo11(
inscricaoEstadual,
new int[] { 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 },
2
);
}
private bool ValidarInscricaoEstadualModulo11(
string inscricaoEstadual,
int[] multiplicadores,
int digitosVerificadores = 1,
bool padLeft = false
) {
if ((inscricaoEstadual.Length - 1) > multiplicadores.Length) {
return false;
}
if (!somenteNumeros.IsMatch(inscricaoEstadual)) {
return false;
}
var inscricaoEstadualPadding = inscricaoEstadual.PadLeft(
multiplicadores.Length + 1,
'0'
);
var semente = inscricaoEstadualPadding.Substring(
0,
inscricaoEstadualPadding.Length - digitosVerificadores
);
// dígitos verificadores
int soma = 0;
for (var i = 0; i < digitosVerificadores; i++) {
soma = SomarProdutos(
semente,
multiplicadores
);
semente += CalculoModulo11(soma);
}
if (semente == inscricaoEstadualPadding) {
return true;
}
return false;
}
JavaScript Gerador
JavaScript Validador
O documento com a definição da estrutura da inscrição estadual do Alagoas e dígitos verificadores pode ser encontrado em: http://www.sefaz.al.gov.br/calculo ou http://www.sintegra.gov.br/Cad_Estados/cad_AL.html
Números de inscrição estadual do Alagoas fáceis de lembrar são: ?? e ??.
Rust Gerador
Rust Validador
C++ Gerador
C++ Validador
C# Gerador
C# Validador
public bool ValidarInscricaoEstadualAlagoas(string inscricaoEstadual) {
if (inscricaoEstadual.Length != 9) {
return false;
}
if (inscricaoEstadual.Substring(0, 2) != "24") {
return false;
}
// não tenho certeza se isso ainda é válido
/*var tipoEmpresa = inscricaoEstadual.Substring(2, 1);
if (tipoEmpresa != "0" // normal
&& tipoEmpresa != "3" // produtor rural
&& tipoEmpresa != "5" // substituta
&& tipoEmpresa != "7" // micro empresa ambulante
&& tipoEmpresa != "8" // micro empresa
) {
return false;
}*/
if (!somenteNumeros.IsMatch(inscricaoEstadual)) {
return false;
}
int resto = 0;
var semente = inscricaoEstadual.Substring(0, inscricaoEstadual.Length - 1);
// dígito verificador
var soma = SomarProdutos(
semente,
new int[] { 9, 8, 7, 6, 5, 4, 3, 2 }
);
soma *= 10;
resto = soma - (soma / 11) * 11;
if (resto == 10) {
resto = 0;
}
semente += resto;
if (semente == inscricaoEstadual) {
return true;
}
return false;
}
JavaScript Gerador
JavaScript Validador
O documento com a definição da estrutura da inscrição estadual do Amapá e dígitos verificadores pode ser encontrado em: http://apl03.sefaz.al.gov.br/sintegra/sintegra/cad_AP.asp
Números de inscrição estadual do Amapá fáceis de lembrar são: ?? e ??.
Rust Gerador
Rust Validador
C++ Gerador
C++ Validador
C# Gerador
C# Validador
public bool ValidarInscricaoEstadualAmapa(string inscricaoEstadual) {
if (inscricaoEstadual.Length != 9) {
return false;
}
if (inscricaoEstadual.Substring(0, 2) != "03") {
return false;
}
if (!somenteNumeros.IsMatch(inscricaoEstadual)) {
return false;
}
int resto = 0;
var semente = inscricaoEstadual.Substring(0, inscricaoEstadual.Length - 1);
// dígito verificador
var soma = SomarProdutos(
semente,
new int[] { 9, 8, 7, 6, 5, 4, 3, 2 }
);
var faixaP = UInt32.Parse(inscricaoEstadual.Substring(2, 6));
byte p = 0;
byte d = 0;
if (faixaP > 0 && faixaP < 17001) {
p = 5;
d = 0;
} else if (faixaP > 17000 && faixaP < 19023) {
p = 9;
d = 1;
} else if (faixaP > 19022) {
p = 0;
d = 0;
}
soma += p;
resto = soma % 11;
resto = 11 - resto;
if (resto == 10) {
resto = 0;
} else if (resto == 11) {
resto = d;
}
semente += resto;
if (semente == inscricaoEstadual) {
return true;
}
return false;
}
JavaScript Gerador
JavaScript Validador
O documento com a definição da estrutura da inscrição estadual do Amazonas e dígitos verificadores pode ser encontrado em: http://www.sintegra.gov.br/Cad_Estados/cad_AM.html
Números de inscrição estadual do Amazonas fáceis de lembrar são: ?? e ??.
Rust Gerador
Rust Validador
C++ Gerador
C++ Validador
C# Gerador
C# Validador
public bool ValidarInscricaoEstadualAmazonas(string inscricaoEstadual) {
return ValidarInscricaoEstadualModulo11Faixa9a2(inscricaoEstadual);
}
private static bool ValidarInscricaoEstadualModulo11Faixa9a2(string inscricaoEstadual) {
return ValidarInscricaoEstadualModulo11(
inscricaoEstadual,
new int[] { 9, 8, 7, 6, 5, 4, 3, 2 },
1,
true
);
}
private bool ValidarInscricaoEstadualModulo11(
string inscricaoEstadual,
int[] multiplicadores,
int digitosVerificadores = 1,
bool padLeft = false
) {
if ((inscricaoEstadual.Length - 1) > multiplicadores.Length) {
return false;
}
if (!somenteNumeros.IsMatch(inscricaoEstadual)) {
return false;
}
var inscricaoEstadualPadding = inscricaoEstadual.PadLeft(
multiplicadores.Length + 1,
'0'
);
var semente = inscricaoEstadualPadding.Substring(
0,
inscricaoEstadualPadding.Length - digitosVerificadores
);
// dígitos verificadores
int soma = 0;
for (var i = 0; i < digitosVerificadores; i++) {
soma = SomarProdutos(
semente,
multiplicadores
);
semente += CalculoModulo11(soma);
}
if (semente == inscricaoEstadualPadding) {
return true;
}
return false;
}
JavaScript Gerador
JavaScript Validador
O documento com a definição da estrutura da inscrição estadual da Bahia e dígitos verificadores pode ser encontrado em: http://www.sintegra.gov.br/Cad_Estados/cad_XX.html ou http://
Números de inscrição estadual da Bahia fáceis de lembrar são: ?? e ??.
Rust Gerador
Rust Validador
C++ Gerador
C++ Validador
C# Gerador
C# Validador
public bool ValidarInscricaoEstadualBahia(string inscricaoEstadual) {
if (inscricaoEstadual.Length > 9) { // pode ser 8 ou 9
return false;
}
if (!somenteNumeros.IsMatch(inscricaoEstadual)) {
return false;
}
var inscricaoEstadualPadding = inscricaoEstadual.PadLeft(9, '0');
int soma = 0;
var semente = inscricaoEstadualPadding.Substring(0, inscricaoEstadualPadding.Length - 2);
var multiplicadores = new int[] { 9, 8, 7, 6, 5, 4, 3, 2 };
int digitoVerificador1 = 0;
int digitoVerificador2 = 0;
var primeiroDigito = inscricaoEstadualPadding.Substring(0, 1);
CalculoModuloBahia calculoModuloBahia = CalculoModuloDummy;
if (primeiroDigito == "0"
|| primeiroDigito == "1"
|| primeiroDigito == "2"
|| primeiroDigito == "3"
|| primeiroDigito == "4"
|| primeiroDigito == "5"
|| primeiroDigito == "8"
) {
calculoModuloBahia = CalculoModulo10Bahia;
} else if (primeiroDigito == "6"
|| primeiroDigito == "7"
|| primeiroDigito == "9"
) {
calculoModuloBahia = CalculoModulo11;
}
// dígito verificador 2 (sim, aqui é o inverso)
soma = SomarProdutos(
semente,
multiplicadores
);
digitoVerificador2 = calculoModuloBahia(soma);
semente += digitoVerificador2;
// dígito verificador 1
soma = SomarProdutos(
semente,
multiplicadores
);
digitoVerificador1 = calculoModuloBahia(soma);
semente = inscricaoEstadualPadding.Substring(0, inscricaoEstadualPadding.Length - 2) + digitoVerificador1 + digitoVerificador2;
if (semente == inscricaoEstadualPadding) {
return true;
}
return false;
}
private delegate int CalculoModuloBahia(int soma);
private int CalculoModulo10Bahia(int soma) {
int resto = soma % 10;
if (resto != 0) {
resto = 10 - resto;
}
return resto;
}
private int CalculoModulo11(int soma) {
int resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
return resto;
}
private int CalculoModuloDummy(int soma) {
return 0;
}
JavaScript Gerador
JavaScript Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
O documento com a definição da estrutura da inscrição estadual do Paraná e dígitos verificadores pode ser encontrado em: http://www.fazenda.pr.gov.br/modules/conteudo/conteudo.php?conteudo=186 ou http://www.sintegra.gov.br/Cad_Estados/cad_PR.html
Números de inscrição estadual do Paraná fáceis de lembrar são: ?? e ??.
main.rs
main.cpp
C# Gerador
public string GerarInscricaoEstadualPR() {
int soma = 0;
int resto = 0;
int[] multiplicadores = new int[] { 4, 3, 2, 7, 6, 5, 4, 3, 2 };
var random = new Random();
string semente = random.Next(1, 99999999).ToString().PadLeft(8, '0');
for (var i = 1; i < multiplicadores.Count(); i++) {
soma += int.Parse(semente[i - 1].ToString()) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
soma = 0;
for (var i = 0; i < multiplicadores.Count(); i++) {
soma += int.Parse(semente[i].ToString()) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
return semente;
}
C# Validador
public bool ValidarInscricaoEstadualParana(string inscricaoEstadual) {
return ValidarInscricaoEstadualModulo11(
inscricaoEstadual,
new int[] { 4, 3, 2, 7, 6, 5, 4, 3, 2 },
2,
true
);
}
private bool ValidarInscricaoEstadualModulo11(
string inscricaoEstadual,
int[] multiplicadores,
int digitosVerificadores = 1,
bool padLeft = false
) {
if ((inscricaoEstadual.Length - 1) > multiplicadores.Length) {
return false;
}
if (!somenteNumeros.IsMatch(inscricaoEstadual)) {
return false;
}
var inscricaoEstadualPadding = inscricaoEstadual.PadLeft(
multiplicadores.Length + 1,
'0'
);
var semente = inscricaoEstadualPadding.Substring(
0,
inscricaoEstadualPadding.Length - digitosVerificadores
);
// dígitos verificadores
int soma = 0;
for (var i = 0; i < digitosVerificadores; i++) {
soma = SomarProdutos(
semente,
multiplicadores
);
semente += CalculoModulo11(soma);
}
if (semente == inscricaoEstadualPadding) {
return true;
}
return false;
}
JavaScript Gerador
function gerarInscricaoEstadualPR() {
let soma = 0;
let resto = 0;
const multiplicadores = [ 4, 3, 2, 7, 6, 5, 4, 3, 2 ];
let semente = let semente = Math.round(Math.random() * 100000000).toString();
semente = semente.substr(0, 8);
for (let i = 1; i < multiplicadores.length; i++) {
soma += parseInt(semente[i - 1], 10) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
soma = 0;
for (let i = 0; i < multiplicadores.length; i++) {
soma += parseInt(semente[i], 10) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
return semente;
}
JavaScript Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
main.rs - Gerador
main.rs - Validador
main.cpp - Gerador
main.cpp - Validador
Program.cs - Gerador
Program.cs - Validador
main.js - Gerador
main.js - Validador
O documento com a definição da estrutura do CPF e dígitos verificadores pode ser encontrado em:
http://www.receita.fazenda.gov.br/publico/Legislacao/atos/AtosConjuntos/AnexoIADEConjuntoCoratCotec0012002.doc.
O nono dígito (logo antes dos 2 dígitos verificadores) costumava ser o código da região fiscal a qual o CPF pertencia. Porém isso aparentemente não é mais o caso.
Números de CPF fáceis de lembrar são: 100.000.000-19 e 000.000.002-72 (o número 000.00.001.91 é proibido conforme o anexo acima).
main.rs
extern crate rand;
use rand::Rng;
fn gerarCpf() -> String {
let mut soma:u32 = 0; // ver depois como usar u8 e o vetor com u8 tb
let mut resto:u32;
let multiplicadores:[u32;10] = [ 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 ];
// 000.000.001-91 é proibido conforme o anexo acima
// portanto o número 1 é excluído da faixa gerada abaixo
let semente = rand::thread_rng().gen_range( 2, 999999999 );
let mut sementeString = format!("{:09}", semente);
let mut sementeVetor:Vec<_> = sementeString
.chars()
.map(|caractere| caractere.to_digit(10).unwrap())
.collect();
for i in 1..10 {
soma += sementeVetor[ i - 1 ] * multiplicadores[ i ];
}
resto = soma % 11;
if resto < 2 {
resto = 0;
} else {
resto = 11 - resto;
}
sementeVetor.push(resto);
soma = 0;
for i in 0..10 {
soma += sementeVetor[ i ] * multiplicadores[ i ];
}
resto = soma % 11;
if resto < 2 {
resto = 0;
} else {
resto = 11 - resto;
}
sementeVetor.push(resto);
sementeString = sementeVetor
.into_iter()
.map(|numero| numero.to_string())
.collect();
return sementeString;
}
main.cpp
#include <random>
#include <sstream> // std::ostringstream
#include <string> // std::stoi
#include <iomanip> // std::setfill
#include <vector> // std::vector
#include <array> // std::array
std::string gerarCpf() {
int soma{0};
int resto{0};
const std::array<int, 10> multiplicadores = { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };
std::random_device randomDevice;
std::default_random_engine generator(randomDevice());
// 000.000.001-91 é proibido conforme o anexo acima
// portanto o número 1 é excluído da faixa gerada abaixo
std::uniform_int_distribution<int> distribution( 2, 999999999 );
auto semente = distribution(generator);
std::ostringstream outputStringStream;
outputStringStream << std::right << std::setfill('0') << std::setw(9) << semente;
auto sementeString{outputStringStream.str()};
std::vector<char> sementeVetor(sementeString.begin(), sementeString.end());
int sementeInt; // conversão de char para int (- '0')
for (int i = 1 ; i < multiplicadores.size(); ++i) {
sementeInt = sementeVetor[ i - 1 ] - '0';
soma += (sementeInt * multiplicadores[ i ]);
}
resto = (soma % 11);
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
outputStringStream << resto;
sementeVetor.push_back(resto + '0'); // conversão de int para char (+ '0')
soma = 0;
for (int i = 0 ; i < multiplicadores.size(); ++i) {
sementeInt = sementeVetor[ i ] - '0';
soma += (sementeInt * multiplicadores[ i ]);
}
resto = (soma % 11);
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
outputStringStream << resto;
return outputStringStream.str();
}
Program.cs
public string GerarCpf() {
int soma = 0;
int resto = 0;
int[] multiplicadores = new int[10] { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };
string semente;
var random = new Random();
do {
semente = random.Next(1, 999999999).ToString().PadLeft(9, '0');
} while (
semente == "000000000"
|| semente == "111111111"
|| semente == "222222222"
|| semente == "333333333"
|| semente == "444444444"
|| semente == "555555555"
|| semente == "666666666"
|| semente == "777777777"
|| semente == "888888888"
|| semente == "999999999"
);
for (int i = 1; i < multiplicadores.Count(); i++) {
soma += int.Parse(semente[i - 1].ToString()) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
soma = 0;
for (int i = 0; i < multiplicadores.Count(); i++) {
soma += int.Parse(semente[i].ToString()) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente = semente + resto;
return semente;
}
main.js
function gerarCpf() {
let soma = 0;
let resto = 0;
const multiplicadores = [ 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 ];
let semente = '';
do {
let sementeFloat = Math.random() * 1000000000;
while(sementeFloat < 99999999) {
semente += '0';
sementeFloat *= 10;
}
semente += sementeFloat.toString();
} while (
semente === '000000000'
|| semente === '111111111'
|| semente === '222222222'
|| semente === '333333333'
|| semente === '444444444'
|| semente === '555555555'
|| semente === '666666666'
|| semente === '777777777'
|| semente === '888888888'
|| semente === '999999999'
);
semente = semente.substr(0, 9);
for (let i = 1; i < multiplicadores.length; i++) {
soma += parseInt(semente[i - 1], 10) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
soma = 0;
for (let i = 0; i < multiplicadores.length; i++) {
soma += parseInt(semente[i], 10) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
return semente;
}
O documento com a definição da estrutura do CNPJ e dígitos verificadores pode ser encontrado em: http://www.receita.fazenda.gov.br/publico/Legislacao/atos/AtosConjuntos/AnexoIADEConjuntoCoratCotec0012002.doc.
Números de CNPJ fáceis de lembrar são: 10.000.000-0009/00 e 00.000.000-0001/91 (números começando com 000 misturados com outros números são proibidos conforme o anexo acima).
Os quatro dígitos após o hífen são referentes ao número da filial da empresa. Portanto o mais comum é 0001.
main.rs
main.cpp
Program.cs
public string GerarCnpj() {
int soma = 0;
int resto = 0;
int[] multiplicadores = new int[] { 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
string raiz;
string sufixo;
var random = new Random();
do {
raiz = random.Next(1, 99999999).ToString().PadLeft(8, '0');
sufixo = random.Next(1, 9999).ToString().PadLeft(4, '0');
} while (
(raiz == "00000000" && sufixo == "0000")
|| (raiz == "11111111" && sufixo == "1111")
|| (raiz == "22222222" && sufixo == "2222")
|| (raiz == "33333333" && sufixo == "3333")
|| (raiz == "44444444" && sufixo == "4444")
|| (raiz == "55555555" && sufixo == "5555")
|| (raiz == "66666666" && sufixo == "6666")
|| (raiz == "77777777" && sufixo == "7777")
|| (raiz == "88888888" && sufixo == "8888")
|| (raiz == "99999999" && sufixo == "9999")
);
string semente = raiz + sufixo;
for (int i = 1; i < multiplicadores.Count(); i++) {
soma += int.Parse(semente[i - 1].ToString()) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
soma = 0;
for (int i = 0; i < multiplicadores.Count(); i++) {
soma += int.Parse(semente[i].ToString()) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
return semente;
}
main.js
function gerarCnpj() {
let soma = 0;
let resto = 0;
const multiplicadores = [ 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 ];
let semente;
let sementeRaiz = '';
let sementeSufixo = '';
do {
let sementeFloatRaiz = Math.random() * 100000000;
while(sementeFloatRaiz < 99999999) {
sementeRaiz += '0';
sementeFloatRaiz *= 10; // TODO correção para zeros à esquerda que irão diminuir a string, melhorar isso
}
sementeRaiz += sementeFloatRaiz.toString();
let sementeFloatSufixo = Math.random() * 10000;
while(sementeFloatSufixo < 999) {
sementeSufixo += '0';
sementeFloatSufixo *= 10;
}
sementeSufixo += sementeFloatSufixo.toString();
} while (
sementeRaiz === '000000000' && sementeSufixo === '0000'
|| sementeRaiz === '11111111' && sementeSufixo === '1111'
|| sementeRaiz === '22222222' && sementeSufixo === '2222'
|| sementeRaiz === '33333333' && sementeSufixo === '3333'
|| sementeRaiz === '44444444' && sementeSufixo === '4444'
|| sementeRaiz === '55555555' && sementeSufixo === '5555'
|| sementeRaiz === '66666666' && sementeSufixo === '6666'
|| sementeRaiz === '77777777' && sementeSufixo === '7777'
|| sementeRaiz === '88888888' && sementeSufixo === '8888'
|| sementeRaiz === '99999999' && sementeSufixo === '9999'
);
semente = sementeRaiz.substr(0, 8) + sementeSufixo.substr(0, 4);
for (let i = 1; i < multiplicadores.length; i++) {
soma += parseInt(semente[i - 1], 10) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
soma = 0;
for (let i = 0; i < multiplicadores.length; i++) {
soma += parseInt(semente[i], 10) * multiplicadores[i];
}
resto = soma % 11;
if (resto < 2) {
resto = 0;
} else {
resto = 11 - resto;
}
semente += resto;
return semente;
}