Toolbox Interactiondesign


Generative Gestaltung Goes Analog 2013

DIY calendar

Lena Hellmann, 02.09.2013 | Generative Gestaltung Goes Analog bei Prof. Dr. Christine Goutrié

Die Idee zur Gestaltung eines Kalenders kam mir bei der Entwicklung der dreidimensionalen Schrift. Allerdings sollten die Liniengebilde für die Monate hierbei wesentlich abstrakter und konfuser eingesetzt werden. Für die Programmierung der Monate März, April, Mai, August und November war der Satz des Pythagoras von Nöten, der sich als Variable in den Code einbinden ließ.

Programmcode zum „DIY calendar“

Der Sketch besteht aus einer Vielzahl von Unterfunktionen, für jeden Monat und für jede Zahlen von 01 bis 31. Sowohl Monate wie auch alle 365 Zahlen werden in void draw() aufgerufen und separat angeordnet.

Für die einfache Positionierung der Monate und Zahlen spielt die Überschaubarkeit des Rasters eine große Rolle. Es erwies sich als hilfreich die Unterteilungen im Vorfeld konkret auf Papier festzulegen und deren Werte dann als Variablen umzuschreiben und den Unterfunktionen zuzuordnen.

Der Kalender ist etwas breiter als DIN A3 und kann mit der Institutsfräse „gezeichnet“ werden.

/*Kalender // Buchstabe und Zahlen 
  Anordnung: 4 Monate waagerecht x 3 Monate senkrecht 
  einfarbig 
*/

//Variablen
int z = 1;                // kleinste einheit fuer die Zahlen 
int lu = 2*z;
int zL = 6*z;             // länste Seite (hoch) bei den Zahlen
float zK = 3.5*z;         // längste Seite - luecke (vertikal) bei den Zahlen
int zKL = 4*z;            // längste Seite (vertikal) bei den Zahlen
int zLL = 8*z;            // komplette Länge
int zM = 2*z;             // Mitte Zahl
int a = z*3;              //kleinste Einheit Kalender-Buchstaben
int Lu =2*a;              //Luecke zwischen den Rasterzellen
int rastB = 22*a;         //Breite Rasterzelle
int rastH = 24*a;         //Hoehe Rasterzelle
float b = 1.090909090;    //Schräge
float c = 0.916666666;

float t = 0;              //Tiefe zum Fräsen

//Anordnung Buchstaben & Zahlen
int Spa = 0*(rastB+Lu);              //Spalte 1 Koordinaten fuer Buchstaben
int Spb = 1*(rastB+Lu);              //Spalte 2 Koordinaten fuer Buchstaben
int Spc = 2*(rastB+Lu);              //Spalte 3 Koordinaten fuer Buchstaben
int Spd = 3*(rastB+Lu);              //Spalte 4 Koordinaten fuer Buchstaben
int Za = 0*(rastH+Lu+zL*6+lu*5+2*Lu);   //Zeile 1 Koordinaten fuer Buchstaben
int Zb = 1*(rastH+Lu+zL*6+lu*5+2*Lu);   //Zeile 2 Koordinaten fuer Buchstaben
int Zc = 2*(rastH+Lu+zL*6+lu*5+2*Lu);   //Zeile 3 Koordinaten fuer Buchstaben
int Zd = 3*(rastH+Lu+zL*6+lu*5+2*Lu);   //Zeile 4 Koordinaten fuer Buchstaben

int ZZa = 0*(rastH+Lu+zL*6+lu*5+2*Lu)+rastH+Lu;   //Zeile 1 Koordinaten fuer Zahlen
int ZZb = 1*(rastH+Lu+zL*6+lu*5+2*Lu)+rastH+Lu;   //Zeile 2 Koordinaten fuer Zahlen
int ZZc = 2*(rastH+Lu+zL*6+lu*5+2*Lu)+rastH+Lu;   //Zeile 3 Koordinaten fuer Zahlen
int ZZd = 3*(rastH+Lu+zL*6+lu*5+2*Lu)+rastH+Lu;   //Zeile 4 Koordinaten fuer Zahlen

//kleine Spalten
int Skla = 0*(zLL+lu);                     //Spalte Zahlenraster
int Sklb = 1*(zLL+lu);
int Sklc = 2*(zLL+lu);
int Skld = 3*(zLL+lu);
int Skle = 4*(zLL+lu);
int Sklf = 5*(zLL+lu);
int Sklg = 6*(zLL+lu);

int Zkla = 0*zLL;                          //Zeilen Rahlenraster
int Zklb = 1*zLL;
int Zklc = 2*zLL;
int Zkld = 3*zLL;
int Zkle = 4*zLL;
int Zklf = 5*zLL;



PrintWriter output;
void setup() {
  background(255);
  stroke(0);
  size(4*rastB+4*Lu, 3*(rastH+Lu+zL*6+lu*5)+5*Lu);
  output = createWriter("Kalender.ngc");
  output.println("%");
  output.println("G 54");
}

/*Auflistung der Monate und der Zahlen pro Monat
  mit den zwei Schrägstrichen wurden die Teile hinausgenommen,
  die in einer anderen Farbe aufgebracht werden sollen
*/

void draw() {
  
  //Monate im Jahr angeordnet 4x3
  J(Spd, Za);
  F(Spc, Za);
  M(Spb, Za);
  A(Spa, Za);
  M(Spd, Zb);
  J(Spc, Zb);
  J(Spb, Zb);
  A(Spa, Zb);
  S(Spd, Zc);
  O(Spc, Zc);
  N(Spb, Zc);
  D(Spa, Zc);
  
  //fuer Januar
  erster (Spd+Sklg, ZZa+Zkla);
  zweiter (Spd+Sklf, ZZa+Zkla);
  dritter (Spd+Skle, ZZa+Zkla);
  vierter (Spd+Skld, ZZa+Zkla);
  fuenfter (Spd+Sklc, ZZa+Zkla);
  sechster (Spd+Sklb, ZZa+Zkla);
  siebter (Spd+Skla, ZZa+Zkla);
  achter (Spd+Sklg, ZZa+Zklb);
  neunter (Spd+Sklf, ZZa+Zklb);
  zehnter (Spd+Skle, ZZa+Zklb);
  elfter (Spd+Skld, ZZa+Zklb);
  zwoelfter (Spd+Sklc, ZZa+Zklb);
  dreizehnter (Spd+Sklb, ZZa+Zklb);
  vierzehnter (Spd+Skla, ZZa+Zklb);
  fuenfzehnter (Spd+Sklg, ZZa+Zklc);
  sechzehnter (Spd+Sklf, ZZa+Zklc);
  siebzehnter (Spd+Skle, ZZa+Zklc);
  achzehnter (Spd+Skld, ZZa+Zklc);
  neunzehnter (Spd+Sklc, ZZa+Zklc);
  zwanzigster (Spd+Sklb, ZZa+Zklc);
  einundzwanzigster (Spd+Skla, ZZa+Zklc);
  zweiundzwanzigster (Spd+Sklg, ZZa+Zkld);
  dreiundzwanzigster (Spd+Sklf, ZZa+Zkld);
  vierundzwanzigster (Spd+Skle, ZZa+Zkld);
  fuenfundzwanzigster (Spd+Skld, ZZa+Zkld);
  sechsundzwanzigster (Spd+Sklc, ZZa+Zkld);
  siebenundzwanzigster (Spd+Sklb, ZZa+Zkld);
  achtundzwanzigster (Spd+Skla, ZZa+Zkld);
  neunundzwanzigster (Spd+Sklg, ZZa+Zkle);
  dreissigster (Spd+Sklf, ZZa+Zkle);
  einunddreissigster (Spd+Skle, ZZa+Zkle);
  
  //fuer Februar
  erster (Spc+Skld, ZZa+Zkla);
  zweiter (Spc+Sklc, ZZa+Zkla);
  dritter (Spc+Sklb, ZZa+Zkla);
  vierter (Spc+Skla, ZZa+Zkla);
  fuenfter (Spc+Sklg, ZZa+Zklb);
  sechster (Spc+Sklf, ZZa+Zklb);
  siebter (Spc+Skle, ZZa+Zklb);
  achter (Spc+Skld, ZZa+Zklb);
  neunter (Spc+Sklc, ZZa+Zklb);
  zehnter (Spc+Sklb, ZZa+Zklb);
  elfter (Spc+Skla, ZZa+Zklb);
  zwoelfter (Spc+Sklg, ZZa+Zklc);
  dreizehnter (Spc+Sklf, ZZa+Zklc);
  vierzehnter (Spc+Skle, ZZa+Zklc);
  fuenfzehnter (Spc+Skld, ZZa+Zklc);
  sechzehnter (Spc+Sklc, ZZa+Zklc);
  siebzehnter (Spc+Sklb, ZZa+Zklc);
  achzehnter (Spc+Skla, ZZa+Zklc);
  neunzehnter (Spc+Sklg, ZZa+Zkld);
  zwanzigster (Spc+Sklf, ZZa+Zkld);
  einundzwanzigster (Spc+Skle, ZZa+Zkld);
  zweiundzwanzigster (Spc+Skld, ZZa+Zkld);
  dreiundzwanzigster (Spc+Sklc, ZZa+Zkld);
  vierundzwanzigster (Spc+Sklb, ZZa+Zkld);
  fuenfundzwanzigster (Spc+Skla, ZZa+Zkld);
  sechsundzwanzigster (Spc+Sklg, ZZa+Zkle);
  siebenundzwanzigster (Spc+Sklf, ZZa+Zkle);
  achtundzwanzigster (Spc+Skle, ZZa+Zkle);
  
  //fuer Maerz
  erster (Spb+Skld, ZZa+Zkla);
  zweiter (Spb+Sklc, ZZa+Zkla);
  dritter (Spb+Sklb, ZZa+Zkla);
  vierter (Spb+Skla, ZZa+Zkla);
  fuenfter (Spb+Sklg, ZZa+Zklb);
  sechster (Spb+Sklf, ZZa+Zklb);
  siebter (Spb+Skle, ZZa+Zklb);
  achter (Spb+Skld, ZZa+Zklb);
  neunter (Spb+Sklc, ZZa+Zklb);
  zehnter (Spb+Sklb, ZZa+Zklb);
  elfter (Spb+Skla, ZZa+Zklb);
  zwoelfter (Spb+Sklg, ZZa+Zklc);
  dreizehnter (Spb+Sklf, ZZa+Zklc);
  vierzehnter (Spb+Skle, ZZa+Zklc);
  fuenfzehnter (Spb+Skld, ZZa+Zklc);
  sechzehnter (Spb+Sklc, ZZa+Zklc);
  siebzehnter (Spb+Sklb, ZZa+Zklc);
  achzehnter (Spb+Skla, ZZa+Zklc);
  neunzehnter (Spb+Sklg, ZZa+Zkld);
  zwanzigster (Spb+Sklf, ZZa+Zkld);
  einundzwanzigster (Spb+Skle, ZZa+Zkld);
  zweiundzwanzigster (Spb+Skld, ZZa+Zkld);
  dreiundzwanzigster (Spb+Sklc, ZZa+Zkld);
  vierundzwanzigster (Spb+Sklb, ZZa+Zkld);
  fuenfundzwanzigster (Spb+Skla, ZZa+Zkld);
  sechsundzwanzigster (Spb+Sklg, ZZa+Zkle);
  siebenundzwanzigster (Spb+Sklf, ZZa+Zkle);
  achtundzwanzigster (Spb+Skle, ZZa+Zkle);
  neunundzwanzigster (Spb+Skld, ZZa+Zkle);
  dreissigster (Spb+Sklc, ZZa+Zkle);
  einunddreissigster (Spb+Sklb, ZZa+Zkle);
  
  //fuer April
  erster (Spa+Skla, ZZa+Zkla);
  zweiter (Spa+Sklg, ZZa+Zklb);
  dritter (Spa+Sklf, ZZa+Zklb);
  vierter (Spa+Skle, ZZa+Zklb);
  fuenfter (Spa+Skld, ZZa+Zklb);
  sechster (Spa+Sklc, ZZa+Zklb);
  siebter (Spa+Sklb, ZZa+Zklb);
  achter (Spa+Skla, ZZa+Zklb);
  neunter (Spa+Sklg, ZZa+Zklc);
  zehnter (Spa+Sklf, ZZa+Zklc);
  elfter (Spa+Skle, ZZa+Zklc);
  zwoelfter (Spa+Skld, ZZa+Zklc);
  dreizehnter (Spa+Sklc, ZZa+Zklc);
  vierzehnter (Spa+Sklb, ZZa+Zklc);
  fuenfzehnter (Spa+Skla, ZZa+Zklc);
  sechzehnter (Spa+Sklg, ZZa+Zkld);
  siebzehnter (Spa+Sklf, ZZa+Zkld);
  achzehnter (Spa+Skle, ZZa+Zkld);
  neunzehnter (Spa+Skld, ZZa+Zkld);
  zwanzigster (Spa+Sklc, ZZa+Zkld);
  einundzwanzigster (Spa+Sklb, ZZa+Zkld);
  zweiundzwanzigster (Spa+Skla, ZZa+Zkld);
  dreiundzwanzigster (Spa+Sklg, ZZa+Zkle);
  vierundzwanzigster (Spa+Sklf, ZZa+Zkle);
  fuenfundzwanzigster (Spa+Skle, ZZa+Zkle);
  sechsundzwanzigster (Spa+Skld, ZZa+Zkle);
  siebenundzwanzigster (Spa+Sklc, ZZa+Zkle);
  achtundzwanzigster (Spa+Sklb, ZZa+Zkle);
  neunundzwanzigster (Spa+Skla, ZZa+Zkle);
  dreissigster (Spa+Sklg, ZZa+Zklf);
  
  //fuer Mai
  erster (Spd+Sklf, ZZb+Zkla);
  zweiter (Spd+Skle, ZZb+Zkla);
  dritter (Spd+Skld, ZZb+Zkla);
  vierter (Spd+Sklc, ZZb+Zkla);
  fuenfter (Spd+Sklb, ZZb+Zkla);
  sechster (Spd+Skla, ZZb+Zkla);
  siebter (Spd+Sklg, ZZb+Zklb);
  achter (Spd+Sklf, ZZb+Zklb);
  neunter (Spd+Skle, ZZb+Zklb);
  zehnter (Spd+Skld, ZZb+Zklb);
  elfter (Spd+Sklc, ZZb+Zklb);
  zwoelfter (Spd+Sklb, ZZb+Zklb);
  dreizehnter (Spd+Skla, ZZb+Zklb);
  vierzehnter (Spd+Sklg, ZZb+Zklc);
  fuenfzehnter (Spd+Sklf, ZZb+Zklc);
  sechzehnter (Spd+Skle, ZZb+Zklc);
  siebzehnter (Spd+Skld, ZZb+Zklc);
  achzehnter (Spd+Sklc, ZZb+Zklc);
  neunzehnter (Spd+Sklb, ZZb+Zklc);
  zwanzigster (Spd+Skla, ZZb+Zklc);
  einundzwanzigster (Spd+Sklg, ZZb+Zkld);
  zweiundzwanzigster (Spd+Sklf, ZZb+Zkld);
  dreiundzwanzigster (Spd+Skle, ZZb+Zkld);
  vierundzwanzigster (Spd+Skld, ZZb+Zkld);
  fuenfundzwanzigster (Spd+Sklc, ZZb+Zkld);
  sechsundzwanzigster (Spd+Sklb, ZZb+Zkld);
  siebenundzwanzigster (Spd+Skla, ZZb+Zkld);
  achtundzwanzigster (Spd+Sklg, ZZb+Zkle);
  neunundzwanzigster (Spd+Sklf, ZZb+Zkle);
  dreissigster (Spd+Skle, ZZb+Zkle);
  einunddreissigster (Spd+Skld, ZZb+Zkle);
  
  //fuer Juni
  erster (Spc+Sklc, ZZb+Zkla);
  zweiter (Spc+Sklb, ZZb+Zkla);
  dritter (Spc+Skla, ZZb+Zkla);
  vierter (Spc+Sklg, ZZb+Zklb);
  fuenfter (Spc+Sklf, ZZb+Zklb);
  sechster (Spc+Skle, ZZb+Zklb);
  siebter (Spc+Skld, ZZb+Zklb);
  achter (Spc+Sklc, ZZb+Zklb);
  neunter (Spc+Sklb, ZZb+Zklb);
  zehnter (Spc+Skla, ZZb+Zklb);
  elfter (Spc+Sklg, ZZb+Zklc);
  zwoelfter (Spc+Sklf, ZZb+Zklc);
  dreizehnter (Spc+Skle, ZZb+Zklc);
  vierzehnter (Spc+Skld, ZZb+Zklc);
  fuenfzehnter (Spc+Sklc, ZZb+Zklc);
  sechzehnter (Spc+Sklb, ZZb+Zklc);
  siebzehnter (Spc+Skla, ZZb+Zklc);
  achzehnter (Spc+Sklg, ZZb+Zkld);
  neunzehnter (Spc+Sklf, ZZb+Zkld);
  zwanzigster (Spc+Skle, ZZb+Zkld);
  einundzwanzigster (Spc+Skld, ZZb+Zkld);
  zweiundzwanzigster (Spc+Sklc, ZZb+Zkld);
  dreiundzwanzigster (Spc+Sklb, ZZb+Zkld);
  vierundzwanzigster (Spc+Skla, ZZb+Zkld);
  fuenfundzwanzigster (Spc+Sklg, ZZb+Zkle);
  sechsundzwanzigster (Spc+Sklf, ZZb+Zkle);
  siebenundzwanzigster (Spc+Skle, ZZb+Zkle);
  achtundzwanzigster (Spc+Skld, ZZb+Zkle);
  neunundzwanzigster (Spc+Sklc, ZZb+Zkle);
  dreissigster (Spc+Sklb, ZZb+Zkle);
  
  //fuer Juli
  erster (Spb+Skla, ZZb+Zkla);
  zweiter (Spb+Sklg, ZZb+Zklb);
  dritter (Spb+Sklf, ZZb+Zklb);
  vierter (Spb+Skle, ZZb+Zklb);
  fuenfter (Spb+Skld, ZZb+Zklb);
  sechster (Spb+Sklc, ZZb+Zklb);
  siebter (Spb+Sklb, ZZb+Zklb);
  achter (Spb+Skla, ZZb+Zklb);
  neunter (Spb+Sklg, ZZb+Zklc);
  zehnter (Spb+Sklf, ZZb+Zklc);
  elfter (Spb+Skle, ZZb+Zklc);
  zwoelfter (Spb+Skld, ZZb+Zklc);
  dreizehnter (Spb+Sklc, ZZb+Zklc);
  vierzehnter (Spb+Sklb, ZZb+Zklc);
  fuenfzehnter (Spb+Skla, ZZb+Zklc);
  sechzehnter (Spb+Sklg, ZZb+Zkld);
  siebzehnter (Spb+Sklf, ZZb+Zkld);
  achzehnter (Spb+Skle, ZZb+Zkld);
  neunzehnter (Spb+Skld, ZZb+Zkld);
  zwanzigster (Spb+Sklc, ZZb+Zkld);
  einundzwanzigster (Spb+Sklb, ZZb+Zkld);
  zweiundzwanzigster (Spb+Skla, ZZb+Zkld);
  dreiundzwanzigster (Spb+Sklg, ZZb+Zkle);
  vierundzwanzigster (Spb+Sklf, ZZb+Zkle);
  fuenfundzwanzigster (Spb+Skle, ZZb+Zkle);
  sechsundzwanzigster (Spb+Skld, ZZb+Zkle);
  siebenundzwanzigster (Spb+Sklc, ZZb+Zkle);
  achtundzwanzigster (Spb+Sklb, ZZb+Zkle);
  neunundzwanzigster (Spb+Skla, ZZb+Zkle);
  dreissigster (Spb+Sklg, ZZb+Zklf);
  einunddreissigster (Spb+Sklf, ZZb+Zklf);
  
  //fuer August
  erster (Spa+Skle, ZZb+Zkla);
  zweiter (Spa+Skld, ZZb+Zkla);
  dritter (Spa+Sklc, ZZb+Zkla);
  vierter (Spa+Sklb, ZZb+Zkla);
  fuenfter (Spa+Skla, ZZb+Zkla);
  sechster (Spa+Sklg, ZZb+Zklb);
  siebter (Spa+Sklf, ZZb+Zklb);
  achter (Spa+Skle, ZZb+Zklb);
  neunter (Spa+Skld, ZZb+Zklb);
  zehnter (Spa+Sklc, ZZb+Zklb);
  elfter (Spa+Sklb, ZZb+Zklb);
  zwoelfter (Spa+Skla, ZZb+Zklb);
  dreizehnter (Spa+Sklg, ZZb+Zklc);
  vierzehnter (Spa+Sklf, ZZb+Zklc);
  fuenfzehnter (Spa+Skle, ZZb+Zklc);
  sechzehnter (Spa+Skld, ZZb+Zklc);
  siebzehnter (Spa+Sklc, ZZb+Zklc);
  achzehnter (Spa+Sklb, ZZb+Zklc);
  neunzehnter (Spa+Skla, ZZb+Zklc);
  zwanzigster (Spa+Sklg, ZZb+Zkld);
  einundzwanzigster (Spa+Sklf, ZZb+Zkld);
  zweiundzwanzigster (Spa+Skle, ZZb+Zkld);
  dreiundzwanzigster (Spa+Skld, ZZb+Zkld);
  vierundzwanzigster (Spa+Sklc, ZZb+Zkld);
  fuenfundzwanzigster (Spa+Sklb, ZZb+Zkld);
  sechsundzwanzigster (Spa+Skla, ZZb+Zkld);
  siebenundzwanzigster (Spa+Sklg, ZZb+Zkle);
  achtundzwanzigster (Spa+Sklf, ZZb+Zkle);
  neunundzwanzigster (Spa+Skle, ZZb+Zkle);
  dreissigster (Spa+Skld, ZZc+Zkle);
  einunddreissigster (Spa+Sklc, ZZb+Zkle);
  
  //fuer September
  erster (Spd+Sklb, ZZc+Zkla);
  zweiter (Spd+Skla, ZZc+Zkla);
  dritter (Spd+Sklg, ZZc+Zklb);
  vierter (Spd+Sklf, ZZc+Zklb);
  fuenfter (Spd+Skle, ZZc+Zklb);
  sechster (Spd+Skld, ZZc+Zklb);
  siebter (Spd+Sklc, ZZc+Zklb);
  achter (Spd+Sklb, ZZc+Zklb);
  neunter (Spd+Skla, ZZc+Zklb);
  zehnter (Spd+Sklg, ZZc+Zklc);
  elfter (Spd+Sklf, ZZc+Zklc);
  zwoelfter (Spd+Skle, ZZc+Zklc);
  dreizehnter (Spd+Skld, ZZc+Zklc);
  vierzehnter (Spd+Sklc, ZZc+Zklc);
  fuenfzehnter (Spd+Sklb, ZZc+Zklc);
  sechzehnter (Spd+Skla, ZZc+Zklc);
  siebzehnter (Spd+Sklg, ZZc+Zkld);
  achzehnter (Spd+Sklf, ZZc+Zkld);
  neunzehnter (Spd+Skle, ZZc+Zkld);
  zwanzigster (Spd+Skld, ZZc+Zkld);
  einundzwanzigster (Spd+Sklc, ZZc+Zkld);
  zweiundzwanzigster (Spd+Sklb, ZZc+Zkld);
  dreiundzwanzigster (Spd+Skla, ZZc+Zkld);
  vierundzwanzigster (Spd+Sklg, ZZc+Zkle);
  fuenfundzwanzigster (Spd+Sklf, ZZc+Zkle);
  sechsundzwanzigster (Spd+Skle, ZZc+Zkle);
  siebenundzwanzigster (Spd+Skld, ZZc+Zkle);
  achtundzwanzigster (Spd+Sklc, ZZc+Zkle);
  neunundzwanzigster (Spd+Sklb, ZZc+Zkle);
  dreissigster (Spd+Skla, ZZc+Zkle);
  
  //fuer Oktober
  erster (Spc+Sklg, ZZc+Zkla);
  zweiter (Spc+Sklf, ZZc+Zkla);
  dritter (Spc+Skle, ZZc+Zkla);
  vierter (Spc+Skld, ZZc+Zkla);
  fuenfter (Spc+Sklc, ZZc+Zkla);
  sechster (Spc+Sklb, ZZc+Zkla);
  siebter (Spc+Skla, ZZc+Zkla);
  achter (Spc+Sklg, ZZc+Zklb);
  neunter (Spc+Sklf, ZZc+Zklb);
  zehnter (Spc+Skle, ZZc+Zklb);
  elfter (Spc+Skld, ZZc+Zklb);
  zwoelfter (Spc+Sklc, ZZc+Zklb);
  dreizehnter (Spc+Sklb, ZZc+Zklb);
  vierzehnter (Spc+Skla, ZZc+Zklb);
  fuenfzehnter (Spc+Sklg, ZZc+Zklc);
  sechzehnter (Spc+Sklf, ZZc+Zklc);
  siebzehnter (Spc+Skle, ZZc+Zklc);
  achzehnter (Spc+Skld, ZZc+Zklc);
  neunzehnter (Spc+Sklc, ZZc+Zklc);
  zwanzigster (Spc+Sklb, ZZc+Zklc);
  einundzwanzigster (Spc+Skla, ZZc+Zklc);
  zweiundzwanzigster (Spc+Sklg, ZZc+Zkld);
  dreiundzwanzigster (Spc+Sklf, ZZc+Zkld);
  vierundzwanzigster (Spc+Skle, ZZc+Zkld);
  fuenfundzwanzigster (Spc+Skld, ZZc+Zkld);
  sechsundzwanzigster (Spc+Sklc, ZZc+Zkld);
  siebenundzwanzigster (Spc+Sklb, ZZc+Zkld);
  achtundzwanzigster (Spc+Skla, ZZc+Zkld);
  neunundzwanzigster (Spc+Sklg, ZZc+Zkle);
  dreissigster (Spc+Sklf, ZZc+Zkle);
  einunddreissigster (Spc+Skle, ZZc+Zkle);
  
  //fuer November
  erster (Spb+Skld, ZZc+Zkla);
  zweiter (Spb+Sklc, ZZc+Zkla);
  dritter (Spb+Sklb, ZZc+Zkla);
  vierter (Spb+Skla, ZZc+Zkla);
  fuenfter (Spb+Sklg, ZZc+Zklb);
  sechster (Spb+Sklf, ZZc+Zklb);
  siebter (Spb+Skle, ZZc+Zklb);
  achter (Spb+Skld, ZZc+Zklb);
  neunter (Spb+Sklc, ZZc+Zklb);
  zehnter (Spb+Sklb, ZZc+Zklb);
  elfter (Spb+Skla, ZZc+Zklb);
  zwoelfter (Spb+Sklg, ZZc+Zklc);
  dreizehnter (Spb+Sklf, ZZc+Zklc);
  vierzehnter (Spb+Skle, ZZc+Zklc);
  fuenfzehnter (Spb+Skld, ZZc+Zklc);
  sechzehnter (Spb+Sklc, ZZc+Zklc);
  siebzehnter (Spb+Sklb, ZZc+Zklc);
  achzehnter (Spb+Skla, ZZc+Zklc);
  neunzehnter (Spb+Sklg, ZZc+Zkld);
  zwanzigster (Spb+Sklf, ZZc+Zkld);
  einundzwanzigster (Spb+Skle, ZZc+Zkld);
  zweiundzwanzigster (Spb+Skld, ZZc+Zkld);
  dreiundzwanzigster (Spb+Sklc, ZZc+Zkld);
  vierundzwanzigster (Spb+Sklb, ZZc+Zkld);
  fuenfundzwanzigster (Spb+Skla, ZZc+Zkld);
  sechsundzwanzigster (Spb+Sklg, ZZc+Zkle);
  siebenundzwanzigster (Spb+Sklf, ZZc+Zkle);
  achtundzwanzigster (Spb+Skle, ZZc+Zkle);
  neunundzwanzigster (Spb+Skld, ZZc+Zkle);
  dreissigster (Spb+Sklc, ZZc+Zkle);
  
  //fuer Dezember
  erster (Spa+Sklb, ZZc+Zkla);
  zweiter (Spa+Skla, ZZc+Zkla);
  dritter (Spa+Sklg, ZZc+Zklb);
  vierter (Spa+Sklf, ZZc+Zklb);
  fuenfter (Spa+Skle, ZZc+Zklb);
  sechster (Spa+Skld, ZZc+Zklb);
  siebter (Spa+Sklc, ZZc+Zklb);
  achter (Spa+Sklb, ZZc+Zklb);
  neunter (Spa+Skla, ZZc+Zklb);
  zehnter (Spa+Sklg, ZZc+Zklc);
  elfter (Spa+Sklf, ZZc+Zklc);
  zwoelfter (Spa+Skle, ZZc+Zklc);
  dreizehnter (Spa+Skld, ZZc+Zklc);
  vierzehnter (Spa+Sklc, ZZc+Zklc);
  fuenfzehnter (Spa+Sklb, ZZc+Zklc);
  sechzehnter (Spa+Skla, ZZc+Zklc);
  siebzehnter (Spa+Sklg, ZZc+Zkld);
  achzehnter (Spa+Sklf, ZZc+Zkld);
  neunzehnter (Spa+Skle, ZZc+Zkld);
  zwanzigster (Spa+Skld, ZZc+Zkld);
  einundzwanzigster (Spa+Sklc, ZZc+Zkld);
  zweiundzwanzigster (Spa+Sklb, ZZc+Zkld);
  dreiundzwanzigster (Spa+Skla, ZZc+Zkld);
  vierundzwanzigster (Spa+Sklg, ZZc+Zkle);
  fuenfundzwanzigster (Spa+Sklf, ZZc+Zkle);
  sechsundzwanzigster (Spa+Skle, ZZc+Zkle);
  siebenundzwanzigster (Spa+Skld, ZZc+Zkle);
  achtundzwanzigster (Spa+Sklc, ZZc+Zkle);
  neunundzwanzigster (Spa+Sklb, ZZc+Zkle);
  dreissigster (Spa+Skla, ZZc+Zkle);
  einunddreissigster (Spa+Sklg, ZZc+Zklf);
  
  noLoop(); 
}


//Unterfunktionen für Kalender // Buchstaben und Zahlen

void A (float e, float f) {
    for (int j = 0; j<= rastB/2 ; j+= a) {
      line (rastB/2+e-j, 0+j*b*2+f, rastB/2+e-j, rastH+f);
      output.println("G0 X"+(rastB/2+e-j)+" Y"+(0+j*b*2+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB/2+e-j)+" Y"+(rastH+f));
      output.println("G0 Z2");
      line (rastB/2+e+j, 0+j*b*2+f, rastB/2+e+j, rastH+f);
      output.println("G0 X"+(rastB/2+e+j)+" Y"+(0+j*b*2+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB/2+e+j)+" Y"+(rastH+f));
      output.println("G0 Z2");
    }
  }

void M (float e, float f) {
    for (int j = 0; j<= rastB ; j+= a) {
      line (rastB+e-j, 0+f+(j*b), rastB+e-j, rastH+f);
      output.println("G0 X"+(rastB+e-j)+" Y"+(0+f+(j*b)));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB+e-j)+" Y"+(rastH+f));
      output.println("G0 Z2");
    }
    for (int j = 0; j<= (rastH/2); j+= a) {
      line (rastB/2-(j*c)+e, rastH/2-j+f, 0+e, rastH/2-j+f);
      output.println("G0 X"+(rastB/2-(j*c)+e)+" Y"+(rastH/2-j+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(0+e)+" Y"+(rastH/2-j+f));
      output.println("G0 Z2");
      line (rastB/2+e-(j*c), rastH/2+j+f, 0+e, rastH/2+j+f);
      output.println("G0 X"+(rastB/2+e-(j*c))+" Y"+(rastH/2+j+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(0+e)+" Y"+(rastH/2+j+f));
      output.println("G0 Z2");
    }
  }

void N (float e, float f) {
    for (int j = 0; j<= rastB ; j+= a) {
    line (rastB+e-j, 0+f+b*j, rastB+e-j, rastH+f); 
      output.println("G0 X"+(rastB+e-j)+" Y"+(0+f+j*b));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB+e-j)+" Y"+(rastH+f));
      output.println("G0 Z2");   
    }
}

void O (float e, float f) {
  for (int i =0; i<= 4*a; i+=a) {
    line (0+e, rastH+f-i, rastB+e, rastH+f-i);
      output.println("G0 X"+(0+e)+" Y"+(rastH+f-i));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB+e)+" Y"+(rastH+f-i));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 6*a; i+=a) {
    line (0+e, 13*a+f+i, 4*a+e, 13*a+f+i);
      output.println("G0 X"+(0+e)+" Y"+(13*a+f+i));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(4*a+e)+" Y"+(13*a+f+i));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 6*a; i+=a) {
    line (12*a+e, 13*a+f+i, rastB+e, 13*a+f+i);
      output.println("G0 X"+(12*a+e)+" Y"+(13*a+f+i));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB+e)+" Y"+(13*a+f+i));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 12*a; i+=a) {
    line (0+e, 0+i+f, rastB+e, 0+i+f);
      output.println("G0 X"+(0+e)+" Y"+(0+i+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB+e)+" Y"+(0+i+f));
      output.println("G0 Z2");
  }
}

void S (float e, float f) {
  for (int i =0; i<= rastB/2; i+=a) {
    line (0+i+e, 0+f, 0+i+e, 6*a+f);
      output.println("G0 X"+(0+i+e)+" Y"+(0+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(0+i+e)+" Y"+(6*a+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= rastB/2; i+=a) {
    line (rastB/2+i+e, 0+f, rastB/2+i+e, 14*a+f);
      output.println("G0 X"+(rastB/2+i+e)+" Y"+(0+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB/2+i+e)+" Y"+(14*a+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 6*a; i+=a) {
    line (rastB/2+e, rastH-i+f, rastB+e, rastH+f-i);
      output.println("G0 X"+(rastB/2+e)+" Y"+(rastH-i+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB+e)+" Y"+(rastH-i+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 14*a; i+=a) {
    line (0+e, rastH+f-i, rastB/2+e, rastH+f-i);
      output.println("G0 X"+(0+e)+" Y"+(rastH+f-i));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB/2+e)+" Y"+(rastH+f-i));
      output.println("G0 Z2");
  }
}

void J (float e, float f) {
  for (int i =0; i<= rastH; i+=a) {
    line (0+e, 0+i+f, 10*a+e, 0+i+f);
      output.println("G0 X"+(0+e)+" Y"+(0+i+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(10*a+e)+" Y"+(0+i+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 6*a; i+=a) {
    line (16*a+e+i, rastH/2+f, 16*a+i+e, rastH+f);
      output.println("G0 X"+(16*a+e+i)+" Y"+(rastH/2+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(16*a+e+i)+" Y"+(rastH+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 6*a; i+=a) {
    line (10*a+e+i, 18*a+f, 10*a+i+e, rastH+f);
      output.println("G0 X"+(10*a+e+i)+" Y"+(18*a+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(10*a+e+i)+" Y"+(rastH+f));
      output.println("G0 Z2");
  }
}

void D (float e, float f) {
  for (int i =0; i<= 6*a; i+=a) {
    line (rastB+e-i, 0+f,rastB+e-i, rastH+f);
      output.println("G0 X"+(rastB+e-i)+" Y"+(0+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(rastB+e-i)+" Y"+(rastH+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 8*a; i+=a) {
    line (0+e, 0+i+f, 16*a+e, 0+i+f);
      output.println("G0 X"+(0+e)+" Y"+(0+i+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(16*a+e)+" Y"+(0+i+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 8*a; i+=a) {
    line (0+e, 16*a+i+f, 16*a+e, 16*a+i+f);
      output.println("G0 X"+(0+e)+" Y"+(16*a+i+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(16*a+e)+" Y"+(16*a+i+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 6*a; i+=a) {              //Mittelteil
    line (0+e, 9*a+f+i, 8*a+e, 9*a+f+i);
      output.println("G0 X"+(0+e)+" Y"+(9*a+f+i));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(8*a+e)+" Y"+(9*a+f+i));
      output.println("G0 Z2");
  }
}

void F (float e, float f) {
  for (int i =0; i<= 12*a; i+=a) {
    line (0+e+i, 0+f, 0+e+i, rastH/2+f);
      output.println("G0 X"+(0+e+i)+" Y"+(0+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(0+e+i)+" Y"+(rastH/2+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 6*a; i+=a) {
    line (6*a+e, rastH/2+i+f, 12*a+e, rastH/2+i+f);
      output.println("G0 X"+(6*a+e)+" Y"+(rastH/2+i+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(12*a+e)+" Y"+(rastH/2+i+f));
      output.println("G0 Z2");
  }
  for (int i =0; i<= 10*a; i+=a) {
    line (12*a+e+i, 0+f, 12*a+e+i, rastH+f);
      output.println("G0 X"+(12*a+e+i)+" Y"+(0+f));
      output.println("G1 Z"+(t)+"F300");
      output.println("G1 X"+(12*a+e+i)+" Y"+(rastH+f));
      output.println("G0 Z2");
  }
}

void erster (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //1
  line (zM+e, 0*z+f, zM+e, zL+f);
  output.println("G0 X"+(e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zM+e, 0*z+f, zM+z+e, 0*z+f);
  output.println("G0 X"+(e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
}

void zweiter (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //2
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+e, zM+f, zKL+e, zL+f);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void dritter (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //3
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zL+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
}

void vierter (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //4
  line (zM+e, 0*z+f, zM+e, zL+f);
  output.println("G0 X"+(zM+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zM+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
}

void fuenfter (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //5
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void sechster (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //6
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void siebter (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //7
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
}

void achter (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //8
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+z*0));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void neunter (float e, float f) {
  //0
  line (zLL+e, 0*z+f, zLL-zK+e, 0*z+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zLL-zK+e, 0*z+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, zL+f, zLL-zK+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zLL+e, 0*z+f, zLL+e, zL+f);
  output.println("G0 X"+(zLL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zLL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //9
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, z*0+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+z*0));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void zehnter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //0
  line (zKL+e, 0*z+f, zKL-zK+e, 0*z+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, zL+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
}

void elfter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //1
  line (zM+e, 0*z+f, zM+e, zL+f);
  output.println("G0 X"+(e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zM+e, 0*z+f, zM+z+e, 0*z+f);
  output.println("G0 X"+(e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
}

void zwoelfter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //2
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+e, zM+f, zKL+e, zL+f);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void dreizehnter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
 //3
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zL+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G0 Z2"); 
}

void vierzehnter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //4
  line (zM+e, 0*z+f, zM+e, zL+f);
  output.println("G0 X"+(zM+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zM+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(-0)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
}

void fuenfzehnter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //5
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void sechzehnter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //6
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void siebzehnter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //7
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
}

void achzehnter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //8
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+z*0));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void neunzehnter (float e, float f) {
  //1
  line (zKL+zM+e, 0*z+f, zKL+zM+e, zL+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+zM+e, 0*z+f, zKL+zM+z+e, 0*z+f);
  output.println("G0 X"+(zKL+e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
  //9
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, z*0+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+z*0));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void zwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //0
  line (zKL+e, 0*z+f, zKL-zK+e, 0*z+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, zL+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
}

void einundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //1
  line (zM+e, 0*z+f, zM+e, zL+f);
  output.println("G0 X"+(e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zM+e, 0*z+f, zM+z+e, 0*z+f);
  output.println("G0 X"+(e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
}

void zweiundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //2
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+e, zM+f, zKL+e, zL+f);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void dreiundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //3
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zL+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
}

void vierundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //4
  line (zM+e, 0*z+f, zM+e, zL+f);
  output.println("G0 X"+(zM+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zM+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
}

void fuenfundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //5
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void sechsundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //6
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void siebenundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //7
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
}

void achtundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //8
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+z*0));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void neunundzwanzigster (float e, float f) {
  //2
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL+e, zM+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zM));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zKL+e+zKL, f+zL, zKL+zKL-zK+e, f+zL);
  output.println("G0 X"+(zKL+e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
  //9
  line (zKL-zK+e, 0*z+f, zKL+e, 0*z+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL+e)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(f+zM));
  output.println("G0 Z2");
  line (zKL-zK+e, zM+f, zKL+e, zM+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL-zK+e, z*0+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(f+z*0));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (e+zKL, f+zL, zKL-zK+e, f+zL);
  output.println("G0 X"+(e+zKL)+" Y"+(f+zL));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zKL-zK)+" Y"+(f+zL));
  output.println("G0 Z2");
}

void dreissigster (float e, float f) {
  //3
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zL+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //0
  line (zKL+e, 0*z+f, zKL-zK+e, 0*z+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zKL-zK+e, 0*z+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, zL+f, zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+e, 0*z+f, zKL+e, zL+f);
  output.println("G0 X"+(zKL+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
}

void einunddreissigster (float e, float f) {
  //3
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL-zK+e, zL+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL-zK+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, 0*z+f, zKL+zKL+e, 0*z+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(0*z+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(0*z+f));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zM+f, zKL+zKL+e, zM+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zM+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zM+f));
  output.println("G0 Z2");
  line (zKL+zKL-zK+e, zL+f, zKL+zKL+e, zL+f);
  output.println("G0 X"+(zKL+zKL-zK+e)+" Y"+(zL+f));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(zKL+zKL+e)+" Y"+(zL+f));
  output.println("G0 Z2");
  //1
  line (zM+e, 0*z+f, zM+e, zL+f);
  output.println("G0 X"+(e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zM)+" Y"+(f+zL));
  output.println("G0 Z2");
  line (zM+e, 0*z+f, zM+z+e, 0*z+f);
  output.println("G0 X"+(e+zM)+" Y"+(f+0*z));
  output.println("G1 Z"+(t)+"F300");
  output.println("G1 X"+(e+zM+z)+" Y"+(f+0*z));
  output.println("G0 Z2");
}

void mousePressed() {                                         //ueber Mausklick im .png Format gespeicherte Bilddatei
  saveFrame("Kalender.png");
  output.println("M 02");
  output.println("%");
  output.flush();
  output.close();
  exit();
  
}
03.09.2013 | Lena Hellmann |