[Note: Coded by Sam Schreiber, who has far* too much time on his hands. This is a C++ parody of Star Wars, in case you can't figure that out.]
[Note: Theoretical Episodes are episodes which have not actually happened in the Star Wars series, which makes them extremely difficult to make parodies of. Work with me here.]

A long time ago, in a computer far* away...

		POINTER
		 WARS

	     EPISODE DOUBLE*
	 DECLARATION OF A UNION

 After the destruction of the Processor,
 there was a great rift in the stack.
 The rebel fleet siezed control over
 the processor, and dictated memory
 until the far* ticks realloced.

 Still, all was not well. The rebellion,
 controlling the ticks, was able to 
 hold the memory aligned. But this
 system could only be temporary.
 The pointers would not stand
 for the few controlling the
 memory. Agent, with this
 knowledge, called an
 urgent reallocing.

{
 starship:battlecruiser (Processor) zeta;
 starship:fighter (Rebel) grain;

 zeta.process("free(&grain)");
 sleep(1);

 zeta.process("free(&grain)");
 sleep(1);

 zeta.process("free(&grain)");
 free(&zeta);
}
{
 Agent.transmit("We the pointers of the united memory, in function to declare a ++ complete union, establish processing, insure local malloc, provide for global private, += the noncast memmalloc, and const the public malloc to our pointers and our pointees, do declare and process this scripted sequence of the united pointers of the heap. \0");
 stinger.transmit("Amazing ! \0");
 coprocessors.transmit("Yes.. yes. \0");

 Ironman.transmit("Do we do this for the united memory, or for ourselves ? Ask yourself this: Is this for the global ++, or is it only for the increasing power of the Rebellion ? \0");
 Ironman.transmit("Why then do you not let the common pointer decide ? \0");
 coprocessors.transmit("Hmm.. \0");
 stinger.transmit("Powerful dwords. \0");

 Agent.transmit("We, the Rebellion, fought to perserve the rights of the common pointer. Do you now, totick, after the freedom is over, proclaim us the enemy ? \0");
 Ironman.transmit("Yes, warmallocer. You and your Rebellion have siezed dictatorian control over the processor. Do you wish to say that you now stand up for what you have already destroyed ? \0");
 Agent.transmit("The Rebellion fought against the Processor's freeing of the heap. Do you claim the processor was right ? \0");
 Ironman.transmit("The stack prospered under the Processor. Billions of pointers were ++. The few that lived in the heap- \0");
 Agent.transmit("Including two pointer masters. \0");
 Ironman.transmit("-were insignifigant. The heap needed to be orphaned. \0");
 Agent.transmit("The Processor was trying to crush the last pointer masters, and give itself global control. \0");
 Ironman.transmit("The common pointer would disagree. \0");

 coprocessors.transmit("This pointer is a threat to the union. \0");
 stinger.transmit("No, the union is a threat to the pointers. \0");
 coprocessors.transmit("The union is the best thing that has happened since Binky's revolution. \0");
 stinger.transmit("Binky's revolution was a failure. Ours must not be. \0");
 coprocessors.transmit("We are Binky's revolution. \0");
 stinger.transmit("You are Binky's revolution. I am the common pointer ! \0");
 coprocessors.transmit("Are you challenging me ? \0");
 stinger.transmit("I'm challeging you ! \0");
}
{
 void* audiance[70000] = {
  void* audiance1[10000];
  int* audiance2[10000];
  char* audiance3[10000];
  float* audiance4[10000];
  double* audiance5[10000];
  FILE* audiance6[20000];
 }

 soldiers:grunt (Ironman) guards[2];

 "And now, the Processor welcomes you to the First Intermemory Pointer Debate ! \0";
 "First, the pointers will give their opening statements, and the debate will begin ! \0";

 Agent.transmit("We the pointers must support the Rebellion, as we create a new and equal processor for all ! \0");
 Ironman.transmit("As long as you support the rebellion, you support anarchy. The rebels are traitors to the Processor, and they took us from a tick of peace to a massive freedom, and now claim that they are to help you ? \0");

 Agent.transmit("The rebellion stopped the Processor from freeing the heap. We are your friend. \0");
 Ironman.transmit("The rebellion destroyed the Stack with your puny war. The heap wasn't worth a pointer, but the Stack, that contained billions of mallocs. All destroyed. Because of you. \0");
 Agent.transmit("We destroyed the Processor, a threat to any malloced pointer. \0");
 Ironman.transmit("And now you want the pointers to support you in making a new one. \0");
 Agent.transmit("A strong, and equal one, for all pointers to live by. \0");
 Ironman.transmit("But why do you want a strong processor ? So that you and the rebels can become controllers of the global Stack ? So that you can crush the innocent pointer with your mallocing and unmallocing commands ? \0");
 Ironman.transmit("I tell you, you cannot let a strong processor rule your commands ! All must act as one, for one, for all ! \0");
 Agent.transmit("Do you not tick what this pointer transmits ? He wants the elimination of a processor ! \0");
 Ironman.transmit("Exactly what you had been fighting for. \0");
 Agent.transmit("We fought for a fair processor, one that would be equal to all. \0");
 Ironman.transmit("That's not what the pointers doing the fighting have to say. \0");

 soldier:veteran (Ironman) tim;
 Ironman.transmit("Tim, what were you fighting for ? \0");
 Ironman.push(&tim, "I was fighting for the destruction of the processor. \0");
 tim.transmit("I was fighting for the destruction of the processor. \0");

 Ironman.push(&tim, "Agh ! Agent, what are you doing to my pointers ! \0");
 tim.transmit("Agh ! Agent, what are you doing to my pointers ! \0");

 Ironman.push(&tim, "tim.collapse()");
 tim.collapse();

 Agent.transmit("I.. I didn't.. \0");
 Ironman.transmit("Agent, you just freed this pointer ! Just because he told the truth ! \0");
 Agent.transmit("I didn't do anything.. you.. \0");
 Ironman.transmit("We need some help over here ! Quickly ! \0");

 soldier:reallocer (Ironman) ted;
 ted.realloc(&tim, sizeof(soldier:verteran));

 Ironman.push(&ted, "Agent, no ! \0");
 ted.transmit("Agent, no ! \0");

 Ironman.push(&tim, "tim.selfdestruct()");
 tim.selfdestruct();

 Ironman.push(&ted, "ted.selfdestruct()");
 ted.selfdestruct();

 Ironman.transmit("My Y-zoo ! Agent, why ? \0");
 Agent.transmit("I didn't.. but.. you.. \0");

 Ironman.transmit("Ag ! Somebody, help me ! \0");
 Ironman.collapse();

 audiance = Agent;
 &Agent--;
 Agent.transmit("No, I didn't do anything. He did it, him, hi-");
 guard[1].capture(&Agent);
 guard.move(&guard-10);
}
{
 Agent.transmit("Let me guess, Ironman is back at full strength. The 'attack' wasn't dangerous at all to him. \0");
 stinger.transmit("What are you implying ? \0");
 coprocessors.transmit("I don't have time for this. The rebellion has been seriously damaged by your performance totick. \0");

 Agent.transmit("You think I couldn't figure that out ? \0");
 coprocessors.transmit("So, why'd you do it ? \0");
 stinger.transmit("I think that he's claiming that he didn't. \0");
 coprocessors.transmit("Oh ? So who did ? \0");

 Agent.transmit("The one that would benifit the most from the destruction of the rebellion. \0");
 coprocessors.transmit("Stinger ?! \0");
 stinger.transmit("How would I benifit ? I simply thought he was convincing. \0");
 coprocessors.transmit("You're saying Ironman blasted himself, and two of his soldiers. \0");
 coprocessors.transmit("And made them transmit that you were doing it. \0");
 Agent.transmit("That is correct. \0");

 coprocessors.transmit("That's ridiculous ! \0");
 Agent.push(&coprocessors, "No it isn't. \0");
 coprocessors.transmit("No it isn't. \0");
 coprocessors.transmit("I didn't just say that. \0");
 Agent.transmit("That's right.. I did. \0");
 coprocessors.transmit("A pointer master.. such power over the memory. \0");
 Agent.transmit("Well, what else happened ? \0");
 stinger.transmit("Coprocessors, just tell him. \0");
 coprocessors.transmit("Ironman has created the pointer militia. He is preparing for war. \0");
}
{
 starship:fighter (Ironman) chadwick[100];
 starship:frigate (Ironman) oppenheimer[20];
 starship:battlecruiser (Ironman) tibbits;

 Ironman.transmit("Just as the rebellion destroyed the Processor, we must now destroy the rebellion. We must rise up and fight for what is ours ! \0");
 Ironman.transmit("If toticks debate goes as planned, the common pointers will be in our mallocs. We can then free the rebellion. \0");
}
{
 Agent.transmit("Another debate ? After the last one ? \0");
 coprocessors.transmit("We believe this may be the last chance for a peaceful resolution. \0");
 stinger.transmit("We have intercepted a transmit. It may indicate this plans for totick. \0");
}
{
 soldier:commando (Ironman) buffer2;
 Ironman.transmit("You planted the transmit ? \0");
 buffer2.transmit("Yes. I believe they intercepted it. \0");
}
{
 void* audiance[70001] = {
  void* audiance1[10000];
  int* audiance2[10000];
  char* audiance3[10000];
  float* audiance4[10000];
  double* audiance5[10000];
  FILE* audiance6[20000];
  buffer2;
 }

 soldiers:grunt (Ironman) guards[][2];

 "And now, the Processor welcomes you to the Second Intermemory Pointer Debate ! \0";

 Agent.transmit("The rebellion has defeat the most dangerous enemy to your mallocing, and now needs your support to keep it that way. Do not support the false enemies of the rebellion, who hope to take control over your memory. Support the rebellion, and recieve an equal processor ! \0");
 Ironman.transmit("The rebellion is the most dangerous enemy to your mallocing. How can their processor be equal if their representative frees the truth and leaves only his lies ? \0");

 coprocessors.transmit("He wasn't supposed to say that. If he.. wait.. \0");
 stinger.transmit("It's a trap ! \0");

 Agent.transmit("Well.. ");
 Ironman.transmit("The rebellion cannot even come up with a response ! \0");
 Agent.transmit("Our processor is.. equal.. well.. because.. what's he doing here ?! \0");
 buffer2.lock(&Agent);

 asaber = Agent.mem;
 asaber = &buffer2;
 free(asaber);

 Ironman.transmit("Now he is killing pointers in the audiance ! Quickly, we must revolt ! \0");
 guards[0].lock(&Agent);
 guards[1].lock(&Agent);
 asaber = &guards;
 free(asaber);
 Ironman.transmit("My guards.. wait.. HELP ! \0");

 soldier:grunt (Ironman) guards[5];
 guards[0].lock(&Agent);
 guards[1].lock(&Agent);
 guards[2].lock(&Agent);
 guards[3].capture(&Agent);
 guards[4].transmit("Agent, you have the function to sleep. \0");
 Ironman.transmit("NOW IS THE TIME FOR THE REVOLUTION ! \0");
}
{
 soldier:grunt (Rebel) truth[2];
 soldier:grunt (Rebel) peace[5];

 coprocessors.transmit("He got arrested. \0");
 stinger.transmit("It wasn't his fault, really. \0");
 coprocessors.transmit("Oh ? \0");
 stinger.transmit("I reviewed the record. Check this out. \0");

 {
  Agent.transmit("Our processor is.. equal.. well.. because.. what's he doing here ?! \0");
  buffer2.lock(&Agent);

  asaber = Agent.mem;
  asaber = &buffer2;
  free(asaber);
 }

 stinger.transmit("Buffer2 locked onto Agent. Agent freed him in self defense ! \0");
 coprocessors.transmit("Yes, yes. I see. What about the guards ? Just freeing his opponents guards is a bit (*-1). \0");
 stinger.transmit("Watch. \0");

 {
  asaber = &buffer2;
  free(asaber);

  Ironman.transmit("Now he is killing pointers in the audiance ! Quickly, we must revolt ! \0");
  guards[0].lock(&Agent);
  guards[1].lock(&Agent);
  asaber = &guards;
  free(asaber);
  Ironman.transmit("My guards.. wait.. HELP ! \0");

  soldier:grunt (Ironman) guards[5];
 }

 stinger.transmit("Again, in self defense. \0");
 coprocessors.transmit("He declared a new array with the same name as the old one. \0");
 stinger.transmit("Yes.. I see that.. \0");
 coprocessors.transmit("That requires him to either overload the first or second. Go back a little. \0");

 {
  void* audiance[70001] = {
   void* audiance1[10000];
   int* audiance2[10000];
   char* audiance3[10000];
   float* audiance4[10000];
   double* audiance5[10000];
   FILE* audiance6[20000];
   buffer2;
  }
 }

 stinger.transmit("There's buffer2. He snuck in at the end. Not even a pointer. \0");
 coprocessors.transmit("Keep on going. \0");

 {
  soldiers:grunt (Ironman) guards[][2];

  "And now, the Processor welcomes you to the Second Intermemory Pointer Debate ! \0";

  Agent.transmit("The rebellion has defeat the most dangerous enemy to your mallocing, and now needs your support to keep it that way. Do not support the false enemies of the rebellion, who hope to take control over your memory. Support the rebellion, and recieve an equal processor ! \0");
 }

 coprocessors.transmit("Zoom in on the declaration of his guards. \0");

 {
  soldiers:grunt (Ironman) guards[][2];
 }

 coprocessors.transmit("Y-ZOO ! HE PLANNED IT ! \0");
 stinger.transmit("Yeah, he probably did plant the assassin.. \0");
 coprocessors.transmit("No, the whole thing ! Look ! \0");

 {
  soldier:grunt (Ironman) guards[][2];
 }

 coprocessors.transmit("How could he possibly know to overload it if he didn't know what Agent would do ? \0");
 stinger.transmit("Meaning.. \0");
 coprocessors.transmit("The entire thing was a setup ! Scripted ! \0");
 stinger.transmit("Where is Agent ? \0");
 coprocessors.transmit("I'm not sure. I think they said. \0");

 {
  guards[2].lock(&Agent);
  guards[3].capture(&Agent);
  guards[4].transmit("Agent, you have the function to sleep. \0");
  Ironman.transmit("NOW IS THE TIME FOR THE REVOLUTION ! \0");
 
  guard.move(&IRONMAN);

  Ironman.transmit("WE MUST DESTROY THE REBELLION, AND HAVE OUR OWN, ONE OF PEACE ! \0");
 }

 coprocessors.transmit("It was a setup, so they could capture Agent ! \0");
 stinger.transmit("Y-zoo ! That means.. ");

 guard[1].fire(&truth);
 truth[1].collapse();
 guard[2].fire(&peace);
 guard[3].fire(&truth);
 guard[4].fire(&peace);
 truth.collapse();
 peace.collapse();
 
 guard[0].lock(&coprocessors);
 guard[1].lock(&stinger);
 guard[2].capture(&coprocessors);
 guard[3].capture(&stinger);
 guard[4].transmit("You have the right to sleep. \0");
 guard[4].transmit("You are accused of being an enemy of the memory. Orders of Ironman. \0");
}
{
 Agent.transmit("You'll pay for this ! Your ticked ticks will tick ! \0");
 Ironman.transmit("Be sleep. \0");
 Ironman.push(&Agent.melt, INF);
 Agent.melt = INF;
 Ironman.transmit("Now, sleep. Let the true pointers rule. \0");

 guard[0].transmit("They're here. \0");
 guard[2].push(&coprocessors, &agent--);
 guard[3].push(&stinger, &agent++);
 Ironman.push(&coprocessors.melt, INF);
 Ironman.push(&stinger.melt, INF);
 Ironman.move(&IRONMAN);
 guard.move(&IRONMAN);

 sleep(10);

 han.push(&Agent.unmelt());
 Agent.melt = 5;
 Agent.melt = 4;
 Agent.melt = 3; 
 Agent.transmit("Han, is that you ? \0"); 
 Agent.melt = 2;
 Agent.melt = 1;
 Agent.melt = 0;
 han.transmit("You recover from an address lock ++. \0");
 Agent.transmit("Thanks. \0");
 han.transmit("I'm hoping that I did the 1 thing in unlocking you. \0");
 Agent.transmit("You did. Can you get coprocessors ? \0");
 han.push(&coprocessors.unmelt());
 Agent.push(&stinger.unmelt());
 coprocessors.melt = 5;
 stinger.melt = 5;
 coprocessors.melt = 4;
 stinger.melt = 4;

 guard.move(&Agent);
 guard[0].lock(&Agent);
 guard[1].lock(&Agent);
 guard[2].lock(&Agent);

 asaber = Agent.mem;
 asaber = guard;
 free(asaber);
 Agent.transmit("Lets go, quickly ! \0");
 Agent.move(&Agent++);
 han.move(&Agent);

 coprocessors.melt = 3;
 stinger.melt = 3;
 coprocessors.melt = 2;
 stinger.melt = 2;
 coprocessors.melt = 1;
 stinger.melt = 1;
 coprocessors.melt = 0;
 stinger.melt = 0;

 coprocessors.transmit("Are we free ? \0");
 stinger.transmit("Is this the great hash table in the heap ? \0");
 coprocessors.transmit("I don't think so. \0");
 stinger.transmit("Lets go then, quickly, before the guards catch us. \0");
}
{
 han.transmit("What happened at those debates ? You don't usually go on free rampages and kill innocent pointers, do you ? \0");
 Agent.transmit("Not twice in two debates. I was set up by Ironman. So he could gain popularity, and eventually destroy the rebellion. \0");
 han.transmit("That's what this pointer militia thing is ? \0");
 Agent.transmit("Tell me about it. \0");
 han.transmit("The pointer militia is made up of 20 divisions of 5 fighters and a cruiser. \0");
 han.transmit("It consists of 100 fighters, 20 cruisers, and Ironman's personal ship, a captured Processor battlecruiser. \0");
 Agent.transmit("Shows where his loyalties are. \0");
 han.transmit("I did some ticking. Ironman was declared in the heap, was taught by Sidious, who was later killed by Croc. \0");
 han.transmit("He fought in the heap wars against Darth, but was lost when a battlecruiser crashed into a bad memory sector in the heap. \0");
 Agent.transmit("He is the Dark Side of the Probability Axis. \0");
 han.transmit("If you say so. Apparently, his battlecruiser was on a mission to seek out and destroy Croc, for what happened to Sidious. \0");
 Agent.transmit("That is why he wants me. I am Croc's only link to the memory. \0");

 starship:transport (Rebel) pod;
 pod.driver = Agent;
 pod.cargo = han;
 pod.move(&REBEL_FLEET);
}
{
 Ironman.transmit("What do you mean they escaped ? \0");
 guard[0].transmit("I'm the only one that made it out alive. \0");
 Ironman.transmit("And then we lost coprocessors and stinger, too. \0");
 guard[0].transmit("The last division sent down there said both were gone. \0");
 Ironman.transmit("Well, find them. NOW ! \0");
 guard.transmit("Alright. \0");
}
{
 alpha.transmit("Agent, you're sure about this ? \0");
 Agent.transmit("It is as important to destroy Ironman as it was the Processor. \0");
 alpha.transmit("I memmalloc. \0");
 Agent.transmit("Pinging all fleets. \0");

 beta.transmit("Pinged. \0");
 gamma.transmit("Pinged. \0");
 delta.transmit("Pinged. \0");
 theta.transmit("Pinged. \0");

 Agent.transmit("We have a horrible mission in front of us. We must destroy Ironman's fleets. \0");
 beta.transmit("Easy. \0");
 theta.transmit("20 cruisers ? Piece of realloc. \0");
 Agent.transmit("It will not be as easy as it seems. Ironman has about half the pointers in the memory on his malloc. \0");
 beta.transmit("That will be a problem. \0");
 delta.transmit("Who are our allies ? \0");
 Agent.transmit("One out of every 3 pointers agrees with us. One out of every four of them will fight for us. \0");
 theta.transmit("1/12 of the pointers will fight on our side. What about the rest ? \0");
 Agent.transmit("One out of 12 pointers have no opinion, one the other 1/12 remain free. \0");
 alpha.transmit("Agent, we just recieved a report from han. I'm putting him on. \0");
 alpha.transmit("Hey Agent, this is han. I think that Ironman's battlecruiser might have a direct line to the processor. We do still control the processor, right ? \0");
 gamma.transmit("We are in full control of the processor. \0");
 alpha.transmit("Yeah, so, that old battlecruiser has a direct line in. Gamma, check for it. Agent, you know what this means, don't you ? \0");
 Agent.transmit("You're saying Ironman could be listening in on us right now ? \0");

 "Why wouldn't I be ? This is all very interesting. You underestimate the power of my militia, though. \0";
 Agent.transmit("Ironman ! \0");
 "That's my char*, don't realloc it. \0";
 Agent.transmit("You just heard our battleplan ! \0");
 "My fleet is moving accordingly. \0";
 Agent.transmit("Gamma, have you found his line yet ? \0");
 "They won't find it. \0";
 gamma.transmit("Not yet. We'll keep looking. \0");
 Agent.transmit("Well, fleets, looks like we'll have to speed up our plans. Go in ! \0");
 "Fool. \0";
}
{
 starship:fighter (Ironman) chadwick[100];
 starship:frigate (Ironman) oppenheimer[20];
 starship:battlecruiser (Ironman) tibbits;

 starship:battlecruiser (Rebel) alpha, beta, gamma, delta, theta;
 starship:fighter (Rebel) routine[20], function[20], capital[20], legacy[20];

 for(int i = 0; i < 100; i++){
  routine[i%20].fire(&chadwick[i]);
  function[i%20].fire(&chadwick[i]);
  capital[i%20].fire(&chadwick[i]);
  legacy[i%20].fire(&chadwick[i]);
 }

 for(int i = 4; i < 20; i+=5){
  alpha.fire(&oppenheimer[i]);
  beta.fire(&oppenheimer[i-1]);
  gamma.fire(&oppenheimer[i-2]);
  delta.fire(&oppenheimer[i-3]);
  theta.fire(&oppenheimer[i-4]);
 }

 for(int w = 4; w < 20; w+=5){
  oppenheimer[w].fire(&alpha);
  oppenheimer[w-1].fire(&beta);
  oppenheimer[w-2].fire(&gamma);
  oppenheimer[w-3].fire(&delta);
  oppenheimer[w-4].fire(&theta);
 }

 for(int w = 0; w < 20; w++){
  chadwick[w].fire(&routine[w]);
  chadwick[w+20].fire(&function[w]);
  chadwick[w+40].fire(&capital[w]);
  chadwick[w+60].fire(&legacy[w]);
 }

 delta.collapse();
 routine.collapse();
 oppenheimer[2].collapse();
 oppenheimer[1].collapse();
 oppenheimer[0].collapse();
 beta.collapse();
 for(int w = 50; w < 100; w++) chadwick[w].collapse();
 oppenheimer[19].collapse();
 oppenheimer[18].collapse();
 oppenheimer[17].collapse();
 capital.collapse();
 oppenheimer[16].collapse();
 oppenheimer[15].collapse();
 oppenheimer[14].collapse();
 oppenheimer[13].colapse();
 chadwick.collapse();
 
 "No, you fools ! I shall destroy you ! \0";
 free(&function);
}
{
 coprocessors.transmit("Hey, what's this function ? \0");
 stinger.transmit("I don't know. It just got called. \0");
 coprocessors.transmit("Watch it. I'll check the next one. \0");
}
{
 free(&legacy);
}
{
 stinger.transmit("It's a line to the processor ! \0");
 coprocessors.transmit("What'd it do ? \0");
 stinger.transmit("It just freed something. Legacy, or something like that. \0");
 coprocessors.transmit("Isn't that a rebel fleet ? \0");
 stinger.transmit("I'm not sure. Come over here. \0");
}
{
 free(&gamma);
 "Bwhahahahahaha ! And now, Agent, you will meet your destiny ! \0");
}
{
 coprocessors.transmit("Gamma was my battlecruiser ! That little.. \0");
 stinger.transmit("He's gonna free Agent ! \0");
 coprocessors.transmit("Help me here. \0");
 coprocessors.push(&tibbits.process(), "free(&tibbits.process())");
}
{
 "And now, Agent, you will die. \0";
 free(&tibbits.process());

 Ironman.transmit("What the- \0");
 coprocessors.transmit("Put your pointers behind your fire() function. \0");
 stinger.lock(&Ironman);
 coprocessors.transmit("You have the right to sleep. We are putting you under pointer's arrest, for violation of subclass 16 under the scripted sequence of the united memory. \0");
 Ironman.transmit("What ! SECURITY ! \0");
 coprocessors.transmit("They're free, Ironman. We met them on the way here. \0");
 stinger.transmit("Clear ? \0");
 coprocessors.transmit("Load him in. \0");

 stinger.capture(&Ironman);

 transport:transport (Rebel) barnacle;
 barnacle.driver = coprocessors;
 barnacle.cargo = Ironman;

 stinger.push(&Ironman.melt, INF);

 coprocessors.transmit("You're not coming ? \0");
 stinger.transmit("He's locked. I have some business to attend to. \0");
}
{
 oppenheimer[4].fire(&theta);
 oppenheimer[7].fire(&alpha);
 oppenheimer[12].fire(&theta);
 oppenheimer[3].fire(&alpha);
 oppenheimer[6].fire(&theta);

 Agent.transmit("Watch out, tibbits is moving in. \0");
 tibbits.lock(&oppenheimer);
 tibbits.fire(&oppenheimer);
 oppenheimer.collapse();

 Agent.transmit("What the.. \0");
 tibbits.transmit("This is stinger, on the tibbits communication stream. The rebellion is in full control of this ship. coprocessors should be flying over now with Ironman. \0");
 Agent.transmit("Good job. The Rebellion is proud of you. And you, coprocessors. \0");
}
{
 void* audiance[70000] = {
  void* audiance1[10000];
  int* audiance2[10000];
  char* audiance3[10000];
  float* audiance4[10000];
  double* audiance5[10000];
  FILE* audiance6[20000];
 }

 Agent.transmit("The traitor Ironman has been freed, and the memory has been cleared of his piratous ships. Now, I annouce to you, the pointers, the new Scripted Sequence of the United Pointers to the Heap. \0");
 Agent.transmit("I shall read it. \0");
 Agent.transmit("We the pointers of the united memory, in function to declare a ++ complete union, establish processing, insure local malloc, provide for global private, += the noncast memmalloc, and const the public malloc to our pointers and our pointees, do declare and process this scripted sequence of the united pointers of the heap. \0");
 Agent.transmit("Subclass 1, preprocessed line 1= 01110101110100 ~1010101010101010110101100101 ~011010010101010101011010 ~10100101 \0");
 Agent.transmit("For those of you who have not yet malloced the preprocessed coding language, it reads as follows: Subclass 1, line 1= We hold these 1 to be 1. That all pointers all malloced equal, that they are malloced by the processor with certain functions, including the function to malloc, to pointee, to... ");
 return Agent;
}