any hacker who sees this, this is property of a math instructor at Baruch College. One Bernard Baruch Way (55 Lexington Ave. at 24th St)
New York, NY 10010     646-312-1000 [The instructor's theory didn't contain double hex's, nor the solution...therefore the double hex's are Open Source].

Double Hex:

7703546418615768424278985289991.1 * 2; 15407092837231536848557970579982

7703546418615768424278985289991.2 * 2; 15407092837231536848557970579982

You could always go online to big number calculator and just read the scientific notation, it's the same.

the idea behind this is that these numbers are sequencing each number with a carry to change the whole number dynamically then at the very end change the whole number with the carry with a similar number that does the same sequence. This doesn't happen often with numbers, they have to be in a specific order.

The calculator doesn't do the computation anymore, just take this number, divide by 3 46221278511694610545673911739947

Found another way to do it. pi^pi / .2^25 then divide by 25, 18 times. make sure you hit enter after dividing, then power the number. I don't believe you can make that power without dividing.

22771395537662478360796733717017

/2

/ 0.66666666666666666666666666666667

=

23110639255847305272836955869973 there's a start.

or
17078546653246858770597550287763 / 6 /

/2
11385697768831239180398366858508 << here [a1]
/ 2 thirds

17078546653246858770597550287763 / 9

1897616294805206530066394476418 / 2
948808147402603265033197238209 / 11

86255286127509387730290658019 prime? start over.

11385697768831239180398366858509 << here [a2] / 11.. cannot divide by 2. scratch that seems to be .1 now.

11385697768831239180398366858508 << here [a1]

 -  .... = 0;

22771395537662478360796733717017 / 11385697768831239180398366858508 = 2.0000000000000000000000000000001 * 3, 3, 3, till whole number. or times 2 til whole number and divide by 256 to get 0.001953125 or times by 16 til whole number then divide by 256; 0.0078125; 0.0078125 - 0.001953125 + 0.001953125 ++; reverse for sequencing numbers within the middle except last two decimal.

 cannot keep dividing by two.

17078546653246858770597550287763 / 9

1897616294805206530066394476418 / 2
948808147402603265033197238209 / 11

86255286127509387730290658019 divide by .999999999... then divide by /2/2/2/2/2/2... till...
11385697768831239180398366858509, end; start over;

It's 46221278511694610545673911739947

somehow I factored a number, now we have two numbers. 10110904674433196056866168193114 cannot divide by 2

or divide by two and this the prime? is this fibonacci?

I guess it only works in binary [sub 2] and [sub 16], I found the remainder of the two in the 46221278511694610545673911739947, made a .2 at the end, since you cannot divide by zero, carry two.

when this happens in pi, take the remainder which is 2 and times it by the number you can find all the factors this way, but since a programming language cannot use big numbers it's literally by hand.

i.e. above / 3 is 15407092837231536848557970579982, divide by two and put numbers herE

7703546418615768424278985289991.2 <-- is this modulus? carrying the remainder in a whole

so 2 * 7 = 14, place 7; 7 * 2 = 14, place 7; 0;

divide from far left the bottom should be your remainder, at the end you carry the two if you add the one dividing it out, the number adds a 1 at the end and makes a whole different number.

Unfortunately a computer cannot handle the big numbers.

You may only use the double hex, any further work on this will involve me discontinuing my studies.

pi(a1b)v =
16 log[sub: 32]^16 - 2 log[sub: 32]16^2 log[n]X

divide by 32, 12 times.

= 32^12 * 16 = pi(a1b)v =
16 log[sub: 32]^16 - 2 log[sub: 32]16^2 log[n]X

pi(a1b)v = pi * 32 / 16 = p /= 2

p /= pi; a1b = x = p^n{u} = n log[sub:: 16]12^[32 - 16] |x|

|a| = |x|; p = 2 when log [sub 16]9 = b = 2690420.0625 = log[sub 16]9^0.0625

b /= 81; b = 1; 9 * 8; 72; [g + h] = f
f= 72 * 12 / 32  = 3^3; && 25^2 / 125 * 16; * 12 * 5 * 9 / 27

double hex f = f` + g` = 81^2 / 27 = g`

double hex f = 12 x 2^3 = 96 / 2^3 = 3;

f` = hex 12 x 2^3[sub3] = 32 /= p

f` = g` + h; f log[sub3](u) + g` log[sub3](U)

u = Z(Z * Z[sub:: p?] * Z / (p - b))
u = 2z^2 + Z log[sub:: p]

u = log [sub 16]9 = b = 2690420.0625 = log[sub 16]9^0.0625 << here
u /= U;

U = V[sub::p] (2f / 2xi(x)) = i = log[p]2f - log[p]x + [g] as log (2 log x^log (n)) = log (n) + log (x) = 2

v ∈ V && F[sub:: p]^x = v`[F][x] ∈ [sub j][x] = 3^x not even

[sub j][x] suppose even; Z * Z[sub:: p] * Z / p^n - k suppose 2 ^ 25 - 0; p^n - k = 32^5 as 33554432; 2^25 ..33554432^16 / 256^10 / 1208925819614629174706176 / ... =  odd or even? pi^pi /.0625^25 is =

46221278511694610545673911739947 will never be pi can't get back?

uhh I use logs by like how many times I divide and mutliply so 12^16 / 16 / 16...  * 16 [x]^.0625 I don't really like to show my work but it works out in most cases if I don't skip a step. ^^ 12^16 / 16 nine times take that number *16 insert for x and put the the power of 0.0625 which is 3. sub 3 can be even.

I actually think I'm worthless when I don't show work so here: 2690420.0625 x 16 / 9 ....repeat... 81 at 6, its not 81 its 7 because (9 / 16 = 0.5625) 0.5625 x 7...x 7...x7 (9 times) is that number...hope you follow now.

"I forgot to say, you said odd or even but that last number is divided by 3 or 4."

sadly you cannot divide by three then two. Even if it's an even number. This is property of Baruch College.

THEORETICAL DOUBLE HEXING THEORY:

f1 = f1p; log <> int = < x * int / int - 2; -- trying to figure out what log to use.

if f1 > int = int - 2 <> log (x) **3 / 216 a s 3 * <2>;; 216 / int = 72^2 - log(n)2^2 -- screwing around with trying to make a decimal then reverse engineer the above problem.

5184

____ x 16 = 82944 / 256;  324n log (n)N^log (n); 12 x 3^x; style of double hexing in [sub j][x] convert to

n

theory of making a decimal turn into a whole number then back into decimal by repeating.

1.125 + 1.125; ...1.125 + 1.125;

<-- Predictive Math