Según GPT, Flash falla en guardar números demasiado grandes. Asumo que el problema es ese.

A ver, tengo una cadena que representa a un binario.

Necesito convertirlo en decimal, pero si es un número falla, así que necesito que sea una cadena.
¿Cómo convierto una cadena que representa a un binario, en una cadena que representa a un decimal? Sin convertirlo todo junto a número porque sino falla.

Luego a la cadena obtenida, que representa a un decimal, necesito dividirla por otro número, nunca tan grande. Y que el resultado sea una cadena también, porque puede ser muy grande.
¿Cómo a una cadena que representa a un decimal, la puedo dividir por un número, de modo que el resultado sea representado por una cadena? Mismo comentario.

Con eso tenemos Decimal y ResultadoDeDivision.

Por último, a Decimal necesito restarle ResultadoDeDivision varias veces, en un loop. Esto parece lo más sencillo, como hacer una resta manualmente, viendo cuales son los últimos caracteres.
¿Cómo a una cadena que representa a un decimal, le puedo restar otra que representa a otro? Mismo comentario.

O quizá sería más fácil hacer las operaciones usando las cadenas binarias, creo que no necesito los decimales.

Le preguntaré a GPT si nadie responde.

Intento resumir y corregir algunos posibles errores que haya cometido en posts anteriores.

Se consigue el número binario que forma la L invertida, aunque es un string:
"1111111011111110111111101111111011111110111111101111111000000000"

Se intenta convertir a decimal, pero como el número resultante es tan grande, Flash falla:
9.22337203685478e+18
Según GPT, el resultado debería ser 18374686492081295424 y el número raro que pone Flash es casi la mitad de eso. Falla.

Entonces, en principio necesito un método de convertir un string que representa un número binario, en un string que represente un decimal, pero sin que dicho método use variables tipo número que sean demasiado grandes, porque sino falla.

El método que usaba, para convertir DibujoEnBinario en DibujoaMostrar, es:

	// Convertirlo en decimal:
	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.round(Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter)));
		trace("Convirtiendo en decimal... "+DibujoaMostrar);
		NroDelCaracter++;
	} while (NroDelCaracter<Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);

Le expliqué a GPT y me dijo esto:

function binaryToDecimalString(binStr) {
    var decimal = "0";
    var i = 0;
 
    while (i < binStr.length) {
        // Multiplicar el decimal actual por 2
        decimal = multiplyDecimalStringByTwo(decimal);
 
        // Sumar el bit actual si es 1
        if (binStr.charAt(i) == "1") {
            decimal = addDecimalString(decimal, "1");
        }
 
        i++;
    }
 
    return decimal;
}
 
// Multiplica un string decimal por 2
function multiplyDecimalStringByTwo(decimal) {
    var result = "";
    var carry = 0;
 
    for (var i = decimal.length - 1; i >= 0; i--) {
        var digit = Number(decimal.charAt(i)) * 2 + carry;
        carry = Math.floor(digit / 10);
        result = String(digit % 10) + result;
    }
 
    if (carry > 0) {
        result = String(carry) + result;
    }
 
    return result;
}
 
// Suma dos strings decimales
function addDecimalString(a, b) {
    var result = "";
    var carry = 0;
    var i = a.length - 1;
    var j = b.length - 1;
 
    while (i >= 0 || j >= 0 || carry > 0) {
        var digitA = i >= 0 ? Number(a.charAt(i)) : 0;
        var digitB = j >= 0 ? Number(b.charAt(j)) : 0;
        var sum = digitA + digitB + carry;
        carry = Math.floor(sum / 10);
        result = String(sum % 10) + result;
        i--;
        j--;
    }
 
    return result;
}

Lo voy a pensar.

Luego creo que tendría que dividir un número entre otro, pero siendo strings, y también tendría que hacer restas usando strings.

En Flash 5 el número entero más grande con el que puedes trabajar es 9007199254740992 (2^53) en en algún momento operas superando ese valor se usarán aproximaciones que obviamente perderán precisión dependiendo cuan alejados estén al límite de 2^53.

Convertir no te sirve porque igual vas a llegar a superar ese valor al intentar realizar alguna operación. Las soluciones que tienes es buscar otra forma dependiendo de como funcione tu programa o lo que quieras lograr, o trabajar todo sin convertirlo completamente, por ejemplo si intentas convertir de binario_string a decimal se te complica porque debes hacer operaciones con números enormes al depender de operaciones que involucran cada caracter

En caso de convertir de binario_string a hexadecimal lo tienes muy sencillo porque tomas de 4 en 4 bits y los conviertes a hexadecimal concatenando todo y ya está, no es necesario trabajar con todos los caracteres ni operar con todos ellos a la vez PERO el problema viene cuando dices: luego debo dividir entre otro número, ahí se rompe todo porque lo tendrás que convertir a número, lo que podrías hacer es crear una función propia para hacer la división, ya sea trabajando todo en binario, o hexadecimal, o decimal (pidiéndole a ChatGPT una función rarísima que ni se entienda XD).

Pues si por ejemplo trabajas en binario_string puro y quieres dividir lo haces como se haría con papel y lápiz a mano (como en el colegio), si el trabajo lo va hacer ChatGPT pues mejor le pides que lo trabaje todo así sin hacer conversiones innecesarias, que cree una función que divida dos binario_string

Ahora bien, con respecto a las calculadoras, la de Windows obviamente no está preparada para esas locuras XD, aunque está el viejo Microsoft Mathematics que no tendría problemas pero es una aplicación más avanzadita, para hacer tus pruebas sin errores yo te recomendaría  SpeedCrunch https://heldercorreia.bitbucket.io/speedcrunch/download.html si deseas puedes bajar la versión instalable o la portable, es muy amigable para los programadores porque es sencillísima, una forma de poner a prueba la calculadora es operando, esta calculadora puede trabajar con números de hasta 78 dígitos sin perder precisión, Excel por otro lado solo puede con 15 dígitos. Por ejemplo con SpeedCrunch:

0b1111111011111110111111101111111011111110111111101111111000000000

Mira que puse el 0b delante, eso es para especificar que estás usando un binario tal cual es 0x para los hexadecimales. Con darle un Enter te devuelve en ese número en Decimal:

18374403900871474688

Servirá como referencia, ahora hago la siguiente operación:

0b1111111011111110111111101111111011111110111111101111111000000000 * 123456789

Como resultado me muestra: 2268444905390666566675256832

Ahora el resultado de la operación anterior lo divido entre 123456789 para ver si obtengo el mismo número de la referencia:

2268444905390666566675256832 / 123456789

Devuelve: 18374403900871474688 que es exactamente igual a la muestra, es más lo puedo convertir a binario con:

bin(18374403900871474688)

dando: 0b1111111011111110111111101111111011111110111111101111111000000000 que es exactamente el binario original, es decir, no pierdes nada de precisión