current ethical poll'ticSZ condition in the drag of keyphrase separation

i have considered a term to permute the notion to make forward the ide acuare of a certain tine in logical orders to make aware a certain qvalse development with the 'operator walling' that currently in conditions to have and go forward with eil, in order to weight out the support of a certain hidden value mix operation on the notion to certainly distinclty pull up on this notion:

the notion in key separation is namely the key walling.

in regards to the key wall, the notion to wall certain keybytes over the wall operators are the term to iterate the bytes of the keyphrase in revaal of their value when at a point in the notion to maintain beta finite mixes over how much value is contained in the keyphrase whereas now to ascribe to the beanmix functions, they soil the ideal weight to beta wearing off the keys in orders revaal of how the wall contains a certain beta phrase where the key is in high order to make fitting the notion to push the beans into totient grad over its wall bus value as such, this is the accupation of vileing the key values in the term moxive what contains each bean value to totient base making forward its mix as a nessie value (over each keyphrase bytes) to make war with a certain qvalse to make the 'wear off' not so much at a term take from the keyphrases alpha value so as much the term of using a nissie as much a wall to permute the finite of the beans into mix totients the acuare current, acuare nessie next totient wall bus is term maybe in the seim to make sure the keyphrase doesnt where too much of its self in reducing the key in hive term whereas there are other ciphers in ria to have them understood to make quals out of the keyphrase in certain ways to tax the key fully with totients moreso you and much more than oneself others know it well the modern ciphers considered high order entropy grade ciphers might as well be certain that there is in one term whereas eil can be considered to make it forward into easily fitting to make it grade block over unsigned long data chunks in accessory to how the keyphrase is permuted, the term to make the operator walling approach the moronism in weleu of eil to have it fit the square term of a proper block cipher the notion to at least experiment with eil as it is totient revaal as such a entropy system to make totients war its accessorys whereas there is as much a keyphrase to much hive to make war with a ciphers construct whereas the key seperation is mainly the algorithms grad atenuee.... moreso this is altogether in orders to make aware that eil can be fashioned to allow high order totient entropy moreso eil is now just in wearing off simply designed as a stream cipher drag order with the hive separation of the key to at least experiment with its current condition to approach a more understood way any notion behind key separation can evolve in a sort of simplistic ideal taste of what simple takes on currently in eil as much keyphrase remain in the dimension of phrase over operator a term of a certain qvalse to make also war in depicting the cipher eil as an experimental base frame for which devolved terms can take weight to allow more complexity in iterative conditions in presses to allow time to term the notion to base fundamental a certain grad whereas there is full allowance to iuca a base simplicity to allow conditions for higher complexity in depictive beta acuares whereas in any scientific permusohn, things take time to make use of valid assumptions

sympath problem draft observation

if we take aa and ev the sympath over the totient operator two bean byte bean bit looks to me like there is sympath possible whereas:

aa has no value whereby, the sympath is possible without ev operations
aa then has the notion to have construct to have bean byte bean bit operate in the fashion of a complex wall in term to name it isqv where:

s is ev operation possible wall totient sympath no value or void of operations ?gluar?
where i is the operation
where q is the sympath operation
where v there remains operations after sympaths are used as ev opertations take place in weleu where no value walls assume a sympath construct for which the key is bussed with novalue where the ev operation takes on walling the aa novalue of the plaintext and ciphertext.

therefore the ev operation could be considered a sympath wall totient base where totorae sympaths are ev bein....

opeind 1: regarding ciphertext 'jumping' in the plaintext mix key mix operation

first of all this is a new idea relating to how currently used ciphers, considerably simply themselves as much how they work, operate on the plaintext with a key separation phase before hand.

in the notion that insomuch the keyconstruct is in term as much i describe, 'could the key permutation mix take on the weleu of ciphertext values' is in term where there isnt much to go by other than one simple benign notion and that is nein hents addition.

the germ of the addition operator is for this specifically because there is a way to not so much use the mix totient walling fully using the '^' 'x' value or [replace 0 with 1 and 1 with zero]

in resistence to its difficulty to imagening the notion to jump ciphertext we must take on the simple insomuch the 'xor' totient bit operation can be fashioned with a term in my mind with the idea of a certain thing called permusohn sympaths.

now in the addition operator we can totient a sympath over the keyphrase and the ciphertext with the addition operator.

this sympath must not so much if at all, in relevance to stageing the notion to construct the sympath logical weight, use any totient mixing namely the use of 'xor'.

we must in eil permute the simple path of the bus of the current key 'phrase' to construct them up and over the bit to construct a higher order of sympaths where the totient is additional permusohns in the sympath weight in notion forward to have in orders, the sympath simply is the term to construct also a path for which the ciphertext must travel over  the keyphrases path to if at all to use at least high order mixing where there is totient operators in use over the keyphrase operation on the plaintext.

in regardence to my current energies and my application of this sympath will take some time but i think its possible to weight the ciphertext and plaintext in a keyphrase sympath to frame the plaintext and ciphertext over keyphrase sympaths. this type of logic in the notion of "algorithms' or 'square resistence framing the keyphrase to permute totients over the plaintext' could change how namely in one culture how ciphers are able to work in a certain manner....

observation 3: how about keyphrases permute in a term whereas somehow there wasnt a germ permusohn in a wall where the key is to take on inblocks

we can take a wall and beta a value over its totient to bus the wall with the next value in uniant beta respose value ALPHAMOXIVE wall operator revaal finite permutation over totient value wall operator next zomo value nessie wall no eil ianu eil wall eyankneu wall eil wall revaal in __finite __wall __there __is __infinite values totient mix in wall beta alpha nessie whereas eil is permuted in hives over the keyphrase.

now let us consider inboxes whereas there is plaintext.

how in germ order can we consider the key to permute without the data adding more vile scill to the mix of a simple assumption and that is is the wall operator great enough to generate beta finite values where the inbox is to take on the permuted key values as beans whereas can the ciphertext to tangle on in the weleu of finite values, be considered key exchange beta moxive permuter mix.

to my mind the ciphertext must take on the key in the plaintext beans to whereas the pemean'T is to in soilist orders, take on canting the plaintext to bean permute also with the key permuted beans.

this to my knowledge is difficult to concieve as much i hive about the weight of the algorithm to remain at a point that it has high entropy value for data encryption purposes, the notion to make war with the plaintext is hardly fathomable but im sure its possible because the plaintext carries an ianu bean totient where the greater the wall totient the more simplistic the ideal weight of freedom goes into simple operators where full totient entropy is possible with key beans and plaintext beans.

i must really try to figure this out, im bent on it!

observation 2: a considerable look at ethics

in the word enigma, we can find a type of puur sympath over the notion the in repudiating, one is term father and one is formal son and one is hive of wife. this is ethic wearness....

whereas, can we wear our mind off in presses where the feedback we get back from certain degrees of grad of somthing in having where there is somthing giving over einm we recieve endearing the notion to hive about the weight of an alignment to at least soil whence somthing comes fences somthing came whereas notion remains at points to have recieved whereas we term the notion to hive about nothing to gain over reasonable ways our mind is to take on the character of its puur symbiath whereas the term in solstice is uuv senes thenei

observation 1: dicpt primatives in key separation

herein to go about the weight of the key separation is the term eil no wall.

the term of using iterations of each keybyte over the bean mix operation where the next keybyte is iterated and compared to the previous keybyte is the notion of operator walling. if we take into consideration that eil is simply not a complex cipher we can divulge a term where we can at least perumute a type of literature finary on the notion that there is simply a wall whereas the operator seem at most to permute a type of boundary in hive formals to certain have aptitude to make the comparative bytes permute what they formerly hold in the terms to make formal the permutebox state hold the xor transformation of the keybytes after the wall operator is at a term a type of 'key separation' construct.

could this wall concept hold in term the notion to make formally that literally mathematics allows at least a value is not so much the value has limit whereas in eil and other ciphers the keyphrase is a limiting factor in how about there is formal permutation in mix operations during the key permutation cophex in the cipher block mixing operations. this wall term whereas the key is notioned to be different than otter strings whereas otter is having the notion to bath a notion informally about the term of no walls contain whereas the passphrase contain a wall song and the wall operator is the term to permute its totient wall supposedly then this is the term of a boundary bus by which values are term high order in notion where separations are formally the weight of each wall permusohn in the germ of boundary 'value' and boundary 'operator construct';

eil key permutation cipher transformation code: 'signing' eil conditioning opeind preodd state :: static amit order 1 :: awon (one) :: sources opind aowon aoloe (two)

#define eilblocksize 32
#define eilkeyblocksize 32
#define u8 unsigned char

unsigned char original_key_state[eilkeyblocksize];
unsigned char keybox[eilkeyblocksize] = {0};
unsigned char permutebox[eilkeyblocksize];
unsigned char permutebilebox[eilkeyblocksize];
int permutestate = 0;
#if 0
typedef union {
 unsigned char a:1;
 unsigned char b:1;
 unsigned char c:1;
 unsigned char d:1;
 unsigned char e:1;
 unsigned char f:1;
 unsigned char g:1;
 unsigned char h:1;
} envy_byte;
/*
envybox[i].a = getbit(key[i], 1);
  envybox[i].b = getbit(key[i], 2);
  envybox[i].c = getbit(key[i], 3);
  envybox[i].d = getbit(key[i], 4);
  envybox[i].e = getbit(key[i], 5);
  envybox[i].f = getbit(key[i], 6);
  envybox[i].g = getbit(key[i], 7);
  envybox[i].h = getbit(key[i], 8);
*/
unsigned char getbit(unsigned char c, int n) {
   return c=(c&(1<<n))>>n;
}

envy_byte envybox[eilkeyblocksize];
unsigned char bean_a[eilkeyblocksize];
unsigned char bean_b[eilkeyblocksize];
unsigned char bean_c[eilkeyblocksize];
unsigned char bean_d[eilkeyblocksize];
unsigned char bean_e[eilkeyblocksize];
unsigned char bean_f[eilkeyblocksize];
unsigned char bean_g[eilkeyblocksize];
unsigned char bean_h[eilkeyblocksize];


void wrap_beans_from_a_to_h()
{
 int i;
 for ( i = 0; i < eilkeyblocksize; i++ )
 {
  bean_a = envybox[i].e 
  envybox[i].d = getbit(key[i], 2);
  envybox[i].f = getbit(key[i], 3);
  envybox[i].d = getbit(key[i], 4);
  envybox[i].a = getbit(key[i], 5);
  envybox[i].h = getbit(key[i], 6);
  envybox[i].b = getbit(key[i], 7);
  envybox[i].g = getbit(key[i], 8);
 }
 

}

void fill_key_into_envybox(unsigned char* key)
{
 int i;
 for ( i = 0; i < eilkeyblocksize; i++ )
 {
  envybox[i].a = getbit(key[i], 1);
  envybox[i].b = getbit(key[i], 2);
  envybox[i].c = getbit(key[i], 3);
  envybox[i].d = getbit(key[i], 4);
  envybox[i].e = getbit(key[i], 5);
  envybox[i].f = getbit(key[i], 6);
  envybox[i].g = getbit(key[i], 7);
  envybox[i].h = getbit(key[i], 8);
 }
}

void bean
#endif

void bean_mixa(unsigned char *key, int current, int addition)
{
 if ( key[current] > key[current+addition] )
  key[current] -= key[current+addition];
 permutebox[permutestate++] = key[current] ^ key[current+addition];
}

void bean_mixb(unsigned char *key, int current, int addition)
{
 if ( key[current] < key[current+addition] )
  key[current] += key[current+addition];
 permutebox[permutestate++] = key[current] ^ key[current+addition];
}


void bean_mix_bilea(unsigned char *key, int current, int addition)
{
 unsigned char bilebyte = key[current];
 bilebyte ^= key[current] + permutebox[current] - (key[current+addition] ^ permutebox[current]);
 if ( key[current] > key[current+addition] )
  key[current] ^= permutebox[current] ;
 permutebilebox[permutestate++] = key[current] ^ bilebyte;
}

void bean_mix_bileb(unsigned char *key, int current, int addition)
{
 unsigned char bilebytea = key[current];
 unsigned char bilebyteb = key[current+addition];
 bilebytea ^= key[current] - permutebox[current] + (key[current+addition] ^ permutebox[current+addition]);
 bilebyteb ^= key[current] + permutebox[current] + (key[current+addition] + permutebox[current]);
 if ( key[current] > key[current+addition] )
  key[current] -= bilebyteb;
 permutebilebox[permutestate++] = key[current] ^ bilebytea ^ bilebyteb;
}
void mix_and_permute_keyblock(unsigned char* key)
{
 int i, j=0;
 for (i = 0; i < eilkeyblocksize; i++)
  original_key_state[i] = key[i];
 for (i = 0; i < eilkeyblocksize; i++) {
  bean_mixa(key, i, j);
  bean_mixb(key, i, j);
  bean_mix_bilea(key, i, j);
  bean_mix_bileb(key, i, j);
  j++;
 }
}

void mix_and_permute_permuteblock(unsigned char* key)
{
 int i;
 for (i = 0; i < eilkeyblocksize; i++) {
  permutebox[i] ^= key[i];
 }
}

void mix_and_permute_permutebileblock(unsigned char* key)
{
 int i;
 for (i = 0; i < eilkeyblocksize; i++) {
  permutebilebox[i] ^= original_key_state[i];
 }
}

void interate_and_permute_key_into_keybox(unsigned char* key)
{
 int i;
 for (i = 0; i < eilkeyblocksize; i++) {  
  keybox[i] = key[i] ^ permutebox[i] ^ permutebilebox[i] ^ original_key_state[i];
 }
}

void put_keystate(u8* key)
{
 mix_and_permute_keyblock(key);
 mix_and_permute_permuteblock(key);
 mix_and_permute_permutebileblock(key);
 interate_and_permute_key_into_keybox(key);
}

#define mix_over_boxes(inblock, outblock, blocksize) \
 { int i; int j; \
 for (j=0; j < blocksize; j++ ) { \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= keybox[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= permutebox[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= original_key_state[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= permutebilebox[i]; \
 } \
 outblock[i] = inblock[i]; \
 } \
 }

#define unmix_over_boxes(inblock, outblock, blocksize) \
 { int i; int j;\
 for (j=0; j < blocksize; j++ ) { \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= permutebilebox[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= original_key_state[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= permutebox[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= keybox[i]; \
 } \
 outblock[i] = inblock[i]; \
 } \
 }
  
void mix_(u8 *block, u8 *outblock, int blocksize)
{
 mix_over_boxes(block, outblock, blocksize) 
}

void unmix_(u8 *block, u8 *outblock, int blocksize)
{
 unmix_over_boxes(block, outblock, blocksize)
}

void encrypt_block(unsigned char* block, unsigned char* outblock, int blocksize)
{
 mix_(block, outblock, blocksize);
}

void decrypt_block(unsigned char* block, unsigned char* outblock, int blocksize)
{
 unmix_(block, outblock, blocksize);
}
#include <stdio.h>
#include <string.h>
int main()
{
 unsigned char* key;
 unsigned char *string = NULL;
 char n = 0;
 int i = 0;
 int j = 0;
 key = (unsigned char*) malloc(eilkeyblocksize);
 memset(key, 0, eilkeyblocksize);
 init_system();
 gather_random_fast(key, eilkeyblocksize);
 put_keystate(key);

 string = (unsigned char*) malloc(1+1);
 fprintf(stderr, "enter plaintext[]:");
 nullru:
 n = getchar();
 if ( n == '\n') goto pillmill;   
 string = (char*) realloc(string, ++j);
 string[j-1] = n;
 goto nullru;
 pillmill:
 encrypt_block(string, string, j);
 string[j+1] = '\0';
 fprintf(stderr, "encrypted: %s\n", string); 
 decrypt_block(string, string, j);
 string[j+1] = '\0';
 fprintf(stderr, "decrypted: %s\n", string); 

 close_system();
 return 0;

}


-----------------------------------------------------------------------------------------------------------


#define eilblocksize 32


#define eilkeyblocksize 32
#define u8 unsigned char

unsigned char original_key_state[eilkeyblocksize];
unsigned char keybox[eilkeyblocksize] = {0};
unsigned char permutebox[eilkeyblocksize];
unsigned char permutebilebox[eilkeyblocksize];
int permutestate = 0;
typedef union {
 unsigned char a:1;
 unsigned char b:1;
 unsigned char c:1;
 unsigned char d:1;
 unsigned char e:1;
 unsigned char f:1;
 unsigned char g:1;
 unsigned char h:1;
} envy_byte;
/*
envybox[i].a = getbit(key[i], 1);
  envybox[i].b = getbit(key[i], 2);
  envybox[i].c = getbit(key[i], 3);
  envybox[i].d = getbit(key[i], 4);
  envybox[i].e = getbit(key[i], 5);
  envybox[i].f = getbit(key[i], 6);
  envybox[i].g = getbit(key[i], 7);
  envybox[i].h = getbit(key[i], 8);
*/
unsigned char getbit(unsigned char c, int n) {
   return c=(c&(1<<n))>>n;
}

envy_byte envybox[eilkeyblocksize];

void bean_mixa(unsigned char *key, int current, int addition)
{
 if ( key[current] > key[(current+addition)%eilkeyblocksize] )
  key[current] ^= key[(current+addition)%eilkeyblocksize];
 permutebox[permutestate++] = key[current];
}

void bean_mixb(unsigned char *key, int current, int addition)
{
 if ( key[current] < key[(current+addition)%eilkeyblocksize] )
  key[current] ^= key[(current+addition)%eilkeyblocksize];
 permutebox[permutestate++] = key[current];
}


void bean_mix_bilea(unsigned char *key, int current, int addition)
{
 if ( key[(current+addition)%eilkeyblocksize] > key[current] )
  key[(current+addition)%eilkeyblocksize] ^= key[current];
 permutebilebox[permutestate++] = key[(current+addition)%eilkeyblocksize];
}

void bean_mix_bileb(unsigned char *key, int current, int addition)
{
 if ( key[(current+addition)%eilkeyblocksize] < key[current] )
  key[(current+addition)%eilkeyblocksize] ^= key[current];
 permutebilebox[permutestate++] = key[(current+addition)%eilkeyblocksize];
}
void mix_and_permute_keyblock(unsigned char* key)
{
 int i, j=0;
 for (i = 0; i < eilkeyblocksize; i++) {
  bean_mixa(key, i, j);
  bean_mixb(key, i, j);
  bean_mix_bilea(key, i, j);
  bean_mix_bileb(key, i, j);
  j++;
 }
}

void mix_and_permute_permuteblock(unsigned char* key)
{
 int i;
 for (i = 0; i < eilkeyblocksize; i++) {
  permutebox[i] += key[i];
 }
}

void interate_and_permute_key_into_keybox(unsigned char* key)
{
 int i;
 for (i = 0; i < eilkeyblocksize; i++) {  
  key[i%eilkeyblocksize] ^= key[((i+1)%eilkeyblocksize)];
  keybox[i] = key[i];
 }
}

void put_keystate(u8* key)
{
 mix_and_permute_keyblock(key);
 mix_and_permute_permuteblock(key);
 interate_and_permute_key_into_keybox(key);
}

#define mix_over_boxes(inblock, outblock, blocksize) \
 { int i; int j; \
 for (j=0; j < blocksize; j++ ) { \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= keybox[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= permutebox[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= original_key_state[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= permutebilebox[i]; \
 } \
 outblock[i] = inblock[i]; \
 } \
 }

#define unmix_over_boxes(inblock, outblock, blocksize) \
 { int i; int j;\
 for (j=0; j < blocksize; j++ ) { \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= permutebilebox[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= original_key_state[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= permutebox[i]; \
 } \
 for ( i = 0; i < eilkeyblocksize; i++) \
 { \
  inblock[i] ^= keybox[i]; \
 } \
 outblock[i] = inblock[i]; \
 } \
 }
  
void mix_(u8 *block, u8 *outblock, int blocksize)
{
 mix_over_boxes(block, outblock, blocksize) 
}

void unmix_(u8 *block, u8 *outblock, int blocksize)
{
 unmix_over_boxes(block, outblock, blocksize)
}

void encrypt_block(unsigned char* block, unsigned char* outblock, int blocksize)
{
 mix_(block, outblock, blocksize);
}

void decrypt_block(unsigned char* block, unsigned char* outblock, int blocksize)
{
 unmix_(block, outblock, blocksize);
}
#include <stdio.h>
#include <string.h>
int main()
{
 unsigned char* key;
 unsigned char *string = NULL;
 char n = 0;
 int i = 0;
 int j = 0;
 key = (unsigned char*) malloc(eilkeyblocksize);
 memset(key, 0, eilkeyblocksize);
 init_system();
 gather_random_fast(key, eilkeyblocksize);
 put_keystate(key);

 string = (unsigned char*) malloc(1+1);
 fprintf(stderr, "enter plaintext[]:");
 nullru:
 n = getchar();
 if ( n == '\n') goto pillmill;   
 string = (char*) realloc(string, ++j);
 string[j-1] = n;
 goto nullru;
 pillmill:
 encrypt_block(string, string, j);
 string[j+1] = '\0';
 fprintf(stderr, "encrypted: %s\n", string); 
 decrypt_block(string, string, j);
 string[j+1] = '\0';
 fprintf(stderr, "decrypted: %s\n", string); 

 close_system();
 return 0;

}

------------------------------------------------------------------------------------------------------------------------

#define eilblocksize 32
#define eilkeyblocksize 32
#define u8 unsigned char

unsigned char* key;
unsigned char original_key_state[eilkeyblocksize];

void bean_mixa(unsigned char *key, int current, int addition)
{
 if ( key[current] > key[current+addition] )
  key[current] ^= key[current+addition];
}

void bean_mixb(unsigned char *key, int current, int addition)
{
 if ( key[current] < key[current+addition] )
  key[current+addition] ^= key[current];
}

void bean_mixc(unsigned char *key, int current, int addition)
{
 if ( key[current+addition] < key[current] )
  key[current+addition] ^= key[current];
}

void bean_mixd(unsigned char *key, int current, int addition)
{
 if ( key[current+addition] > key[current] )
  key[current+addition] ^= key[current];
}

void mix_and_permute_keyblock(unsigned char* key)
{
 int i, j=0;
 for (i = 0; i < eilkeyblocksize; i++)
  original_key_state[i] = key[i];
 for (i = 0; i < eilkeyblocksize; i++) {
  bean_mixa(key, i, j+1%eilkeyblocksize);
  bean_mixb(key, i, j+1%eilkeyblocksize);
  bean_mixc(key, i, j+1%eilkeyblocksize);
  bean_mixd(key, i, j+1%eilkeyblocksize);
  j++;
 }
 j=0;
 for (i = 0; i < eilkeyblocksize; i++) {
  bean_mixa(key, i, j+1%eilkeyblocksize);
  bean_mixb(key, i, j+1%eilkeyblocksize);
  bean_mixc(key, i, j+1%eilkeyblocksize);
  bean_mixd(key, i, j+1%eilkeyblocksize);
  j++;
 }
}

void put_keystate(u8* key)
{
 mix_and_permute_keyblock(key);
}

#define mix_over_boxes(inblock, outblock, blocksize) \
 { int j; unsigned char n; \
 for (j=0; j < blocksize; j++ ) { \
  n = inblock[j]; \
  { int i; for(i=0;i<eilkeyblocksize;i++) { \
  n ^= original_key_state[i]; \
  n ^= key[i]; \
  } \
  } \
  outblock[j] = n; \
 } \
 }

#define unmix_over_boxes(inblock, outblock, blocksize) \
 { int j; unsigned char n; \
 for (j=0; j < blocksize; j++ ) { \
  n = inblock[j]; \
  { int i; for(i=0;i<eilkeyblocksize;i++) { \
  n ^= key[i]; \
  n ^= original_key_state[i]; \
  } \
  } \
  outblock[j] = n; \
 } \
 }
  
void mix_(u8 *block, u8 *outblock, int blocksize)
{
 mix_over_boxes(block, outblock, blocksize) 
}

void unmix_(u8 *block, u8 *outblock, int blocksize)
{
 unmix_over_boxes(block, outblock, blocksize)
}

void encrypt_block(unsigned char* block, unsigned char* outblock, int blocksize)
{
 mix_(block, outblock, blocksize);
}

void decrypt_block(unsigned char* block, unsigned char* outblock, int blocksize)
{
 unmix_(block, outblock, blocksize);
}
#include <stdio.h>
#include <string.h>
int main()
{
 unsigned char *string = NULL;
 unsigned char *out = NULL;
 unsigned char *out_ = NULL;
 char n = 0;
 int j = 0;
 key = (unsigned char*) malloc(eilkeyblocksize);
 memset(key, 0, eilkeyblocksize);
 init_system();
 gather_random_fast(key, eilkeyblocksize);
 put_keystate(key);

 string = (unsigned char*) malloc(1);
 fprintf(stderr, "enter plaintext[]:");
 nullru:
 n = getchar();
 if ( n == '\n') goto pillmill;   
 string = (char*) realloc(string, ++j);
 string[j-1] = n;
 goto nullru;
 pillmill:
 if ( !out )
 out = (unsigned char*) malloc(j);
 else
 out = (unsigned char*) realloc(out, j);

 encrypt_block(string, out, j);
 if ( !out_ )
  out_ = (unsigned char*) malloc(j);
 else
  out_ = (unsigned char*) realloc(out_, j);

 { int i; fprintf(stderr, "plaintext values in decimals: "); for(i=0; i < strlen(string); i++) fprintf(stderr, "%d ", string[i]); }
 fprintf(stderr, "\nencrypted: encrypted values in decimals: "); 
 { int i; for(i=0; i < strlen(string); i++) fprintf(stderr, "%d ", out[i]); }
 decrypt_block(out, out_, j);
 fprintf(stderr, "\ndecrypted: decrypted values in decimals: ");
 { int i; for(i=0; i < strlen(string); i++) fprintf(stderr, "%d ", out_[i]); }

 return 0;

}