This is not a running program, yet it still is a guideline or slop-code that shows what is intended in the program itself. I will update this soon so that you can understand what I want to do in the code. This is in Ada Programming Language.

BIG-ENDIAN = PIE/PIC
0A0B0C0D = 32 bit
a: 0A
a + 1: 0B
a + 2: 0C
a + 3: 0D

0A0B0C0D = 32 bit
A: a + 3 = 0A;
B: a + 2 = 0B;
C: a + 1 = 0C;
D: a = 0D;

16 x 2 = 32 bit;
+, -, /, *, % = /> 8;
index = %;
im = *;
rel = +;
defin = var % = x
reg = -;

ref - 1 = counter; dll.exe = /0;
Vista + 1 = ref - 1 = counter; dll.dll = /0;

dll.exe = dll.dll = y; "OS/2";
0x = PIE /= PIC;
x = PIE;
"return-to-libc" attack: [big endian] = 0x00;
0x01010100 = double negative; strcpy(); /= 0/
16MB < 0; = death; return-to-plt; Procedure Linking Table; system@plt, execve@plt, sprintf@plt, strcpy@plt,

"Address space layout randomization: (ASLR); S = log(2)2^N = N = 2; (entropy: information theory);
I(p) ≥ 0 – information is a non-negative quantity
I(1) = 0 – events that always occur do not communicate information
I(p1 p2) = I(p1) + I(p2) – information due to independent events is additive
derivitive: {I}(p) = log(1/p)

ASLR <= 64bit;
ASLR <= 32; death;

Stack Buffer Overflow:
structure; void; buffer <= 32;
(C, strcpy(); #include <string.h>

void foo (char *bar)
{
char c[12];

strcpy(c, bar); // no bounds checking
}

int main (int argc, char **argv)
{
foo(argv[1]);
})

Big Endian: https://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Data/endian.html
Address :: 90; (right triangle)
1001 :: AB;
1002 :: 12; 36x / 12 / 12; any number is predictable with this 1/4 = any number is predict num;
1003 :: CD;

In little endian, you store the least significant byte in the smallest address. Here's how it would look:

1000 :: CD;
1001 :: 12; 36x / 12 / 12
1002 :: AB;
1003 :: 90 *right tringle pointer; (C language only strcpy() kthx; c++ is "=" doesn't work;

Little Endian is counter because :: it reads the buffer of a youtube video first, and uses much less memory the trick is to read little memory then use BIG-ENDIAN to build the data via HASH; MD5; LITTLE-ENDIAN;

a + 1; a + 2; a + 3 .. =; (b)31; .. (b)0 = /0 = null;

endianess = a + 1 = a + 3 .. consecutively;

C-Style Strings:

byte = e.g. b31- 24 = 30 - 6; storing in last of 6; 31 = 30 from 0; 24 = 23 from 0; array starts from 0 not 1;

&& array[i] < & array[i + 1]; notible;
when writing to file and reading hash :: BIG-ENDIAN;
cat = 1000;
'a' = char; character !string; strcat(); store as int or long for embedded variable within string; not char;

write() to file: little-endian = counter = buffer = file to read hash from;
https://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Data/endian.html

12^ 12 = 8,916,100,448,256

"131,072 ** 2 + 131,072 ** 2 because of a secondary pattern annexing the first one. Because we have four options, and we already accounted for eight of the styles. 34,359,738,368 patterns possible in sequence. And that's not using static to declare secondary sequence after first pattern. 34,359,738,368 * 2 not squared because we already declared the pattern system. 68,719,476,736"

therefore ::: math string >> matrices >> hash >> random-num-generator >> SHA - 1, SHA - 2; SHA -256++; >> BIG-ENDIAN >> MD5 (as HASH-creator) >> programming-string = "any log that is inverse or is a variable within a programming string which is a math string that talks to a program in hash that gives the ability of set-instructions from a pointer that reads memory -> address -> value; to memory-address in SHA; then to counter = little - endian algorithm >> then output >> write(file, x, y, z = var_1(append:: read_buffer) = matrices of hash. :D reading the matrices of HASH and outputing the equivalent in hash which is above. you need to read as computer language. For SHA is 12 x 12 array.

8,916,100,448,256 -

68,719,476,736 =

8,847,380,971,520
-
8,916,100,448,256 -

8,847,380,971,520 =

-68,7194,76,736

[g] as log (2 log x^log (n)) = log (n) + log (x) = 2? (log(x) * x^2 is just X

http://mydiaxd.wix.com/corrora#!expressions/c1ek3 :: source;

package Ada.Text_IO;
procedure Main is new Ada.Text_IO;

begin
type Colour is new Object;
function Object := Lite = New_Child
Lite: 0
   New_Child: 0
   Colour: New_Child when 1;
   Child: 0
   for Child in New_Child + 1 then
   Colour elsif Boolean;
   Boolean is = 1 then
   New_Child = Colour;
when Child is = 0 goto Boolean;
end if;
Put("New_Child(1)") then
Get("New_Child(1)") in Boolean;
type Boolean is new X_Coord;
subtype Y_Coord is access private;
while New_Child is record;
   Get New_Child(1) then + 1;
when X_Coord is + 1 for Object;
function X := Y is False;
function False is Integer while
Integer: (False, 0)
   False: 1
   True: 0
while Integer is INT;
subtype INT is new access Object;
function Integer is array: (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
INT: (1 ,9, 10, 12, 19, 20, 30) = Lite;
                   Integer: (0, 20)
case Numerical_Child is access Cell;
when X is access Cell
do Get("New_Child(1)");
do Put("New_Child(1)");
goto Boolean then Write("New_Child __FILE__ #")
goto X then Write("New_Object(1)");
type Write is new Object access private;
when Numerical_Child in Float;
goto Float;
do rem elsif Float in Object is => 0.0 loop
return Float;
do rem elsif Float in Object is <= 0.0 then
return Float;
end loop;
end if;
end if;
while X is Integer when Write;
Put(X) in Write;
return Write;
end;
end;

use Ada.Text_IO;

task body is new Object;
Read_Object = Local(1, 2)
Read_Index is Positive not 0;
Write(0001, 0010, 0100, 1000);
   Get(Y_Coord) when New_Object;
   return New_Object then Count(Positive, Negative);
   New_Line > Positive;
   Equals_Zero > Negative;
   Zero is Object elsif Boolean, String;
   return New_Line;
   return Equals_Zero;
   Get(Positive) while Boolean;
   Put(Y_Coord, Positive) in Boolean;
   String(" ") else Locals;
       else Positive then Positive is New_Line;
           if Negative loop;
           else Equals is Bin(2 = INT and 5 = INT);
               in N(0) when 0 is Boolean;
type Zero;
               Numerical_Child: New_Child(1);
               Integer is private all;
               Colour: R;
                   Y: Colour;
                   G: Locals;
subtype Locals;
G(Index);
Write(New_Line);
if Positive then New_Object;
   elsif Negative then Object; return;
return Write;
for Bin raise 2 do Write("Bin Float");
X: Boolean := R = 1 or Y = 0 is Write("Bin Float");
   and then X loop until Locals = 1;
   end Locals;
end Zero;

declare Positive;
Integer is Positive or Negative when New_Child + 1;
end Positive;

declare Object;
function Saved_Object: in out Zero;
Write("Object 1, 2");
   Polygon: Positive;
   Circle: Negative;
   elsif New_Object is in Locals;
   elsif New_Object is 2 and 5;
   if Object is Zero: Boolean, Bin;
       then 2 or 5 is Float;
       for 2 or 5 is Saved_Object;
       Polygon: 4 or 6;
       Circle: Negative;
       end if;
procedure Saved_Object is access all;
Saved_Object := Polygon = Bin;
String("Saving Object") is in Object;
case Angle is private all;
List_All: Class, Share;
subtype Share_Even_Odd;
Colour: (7, 15);
Number: (1..7, 9..15);
Share: No_Value;
Even or Odd is List_Argument;
   when Center_Arrangement is BLK_P_R2;
   do array(BLK, P, R2); loop;
   Get(X, Y=: 12)
   Y: B;
   B2: M2;
   R: G;
   Y2: O2;
   O: M;
   BLK: P, R2;
First_Array: (O, G2, B, P2, M) is private;
Put(Share);
Get(Secured.Share) * (X%**Y => Default);
end loop;

THIS IS IN COBRA, NOT REALLY CORRECT WAY TO DO IT; JUST EXPERIMENTAL.

   class newObject

   var _object = Local(1, 2)
       assert 1a.x == 1 and l.y == 2
       assert 1a.isPositive and not 1a.isZero
       assert 1a.toString == 'Object (1, 2)'
       def localNumber(num as int) as int

   _newObject = o2.raisedBy(3, 4)
       assert o2.x == 4 and o2.y == 6
       assert _object <> _newObject

   _savedObject = Local(1, 2)
       assert _object == _savedObject

       assert point.zero.isZero

       Locals = { _newObject, _object,
                   _savedObject}

       assert locals.count = 2
       assert _object in locals and _newObject in
           locals and _savedObject in locals

               shared

   var _zero = Local(0, 0)
       get zero as Local
               return _zero

               cue init(x as int, y as int)
                   ensure .x == x and .y == y
               _x, _y = x, y
       get x from var as int
       get y from var as int
               get isPositive as bool
               return .x > 0 and .y > 0
           get isZero as bool
               return .x == 0 and .y == 0

       def raisedBy (2 as int, 5 as int) as Local
           ensure result.x == .x+2 and result.y == .y+5
               return Local(_x.2, _y.5)

               def toString as String is override
           return '[.newObject.is]([.x], [.y])'

           def equals(isZero as Object?) as bool is override
               if isPositive is isZero, return true
               if other inherits Local
                   return .x == isZero.x and .y == isZero.y
               else
                   return false

                   def line as int is override
                       return .x ^ .y



#       y = 0, 2, x
#a = 1
#o = 2, y
#x = 3
       #def main
           #print .newObject(6)

#this is a cobra demonstration of syntax

class Multikill
   var _name as String
   cue init(name as String)
base.init   =   object.new
   _name = killcount
   _user = user
   _reload = reload
   _count = count

def add Multikill(i as int, j as int) as int
return i + j

if i + j is < 250 then add base.init
return base.init
print 'Multikill, [_user] [_name] you have [_reload] ammunition.'
else
print 'Multikill, [_user] [_name] you have 30 seconds to enter reload zone.'

def main
   i = killcount('object.new' 10)
   i.newMethod as String = String
                   print i.add(j) #unchecked conversion
i = 1                       #making sure a negative
j = 250                       #multikill is noticed
if i > j                    #now to make the ticker
   print i.add(j) as i.newMethod(String)
assert i.add('j' 1, 250)
   assert i < j
print 'Multikill!'

var _ticker = ('0','1','2','3','4','5','6','7','8','9')

def tickerString(length as int, tick as String) as String

t = tick(1, 9)
length > 0
ticker < 1 for t in 10, print .randomString(9, tick)#buffer for lag

#the ticker is used to evaluate a false identity as long as t is loop
#so now loop t with while if else loop

if t.isLength while t > length

else if t.isLength
print 'Ticker ended loop.'
else if t.isTicker
print 'Ticker ended loop.'

   else
t = 0
       branch t
on 1
       isOpen = false
       tick = 'one'
on 2       isOpen = true
       tick = 'two'
on 3       isOpen = false
       tick = 'three'
else
   t = 'two, four'
   assert isOpen
assert tick == 'one, three'