Private Sub Form_Load()
Dim i As Integer
On Error GoTo ohnoez
i = 1
start:
MsgBox "Du bist alle " & i & "x verwarnt!"
i = i + 1
GoTo start

ohnoez:
i = 0
GoTo start
End Sub

import java.io.*;

public class fu extends Thread{
	private int me, myData, recData, sendData, n;
	private PipedInputStream in;
	private PipedOutputStream out;
	
	public fu(int me, PipedInputStream in, 
			PipedOutputStream out, int n){
		
		this.me = me;
		this.in = in;
		this.out = out;
		this.n = n;
	}
	public void run(){
		try{
			DataInputStream dataIn = new DataInputStream(in);
			DataOutputStream dataOut = new DataOutputStream(out);
			
			
			
			yield();
			myData = dataIn.readInt();
			
			while(true){
				yield();
				
				recData = dataIn.readInt();
				if(recData == Integer.MAX_VALUE){
					dataOut.writeInt(recData);
					break;
				}
				if((recData % myData) != 0){
					sendData = recData;
					
				}
				if(me < n-1){
					dataOut.writeInt(sendData);
					dataOut.flush();
				}
				
			}
		}catch(Exception e){e.printStackTrace();};
		
	}
	public int getMyData(){
		return myData;
	}
	public static void main(String[] args) {
		try{
			int[] a = new int[25];
			final int NMAX = 5;
			
			for(int i = 0 ; i < a.length; i++){
				a[i] = i+2;
			}
			PipedInputStream[] in = new PipedInputStream[NMAX];
			PipedOutputStream[] out = new PipedOutputStream[NMAX];
			fu[] lol = new fu[NMAX];
			for(int i = 0; i < NMAX; i++){
				in[i] = new PipedInputStream();
				out[i] = new PipedOutputStream();
			}
			for(int i = 0; i < NMAX; i++){
				out[i].connect( in [ (i+1)%NMAX ]);
				lol[i] = new fu(i, in[i], out[i], NMAX);
				lol[i].start();
			}
			DataOutputStream dataOut = new DataOutputStream(out[NMAX-1]);
			for(int i = 0; i < a.length; i++){
				dataOut.writeInt(a[i]);
				dataOut.flush();
			}
			
			dataOut.writeInt(Integer.MAX_VALUE);
			
			
			
			lol[NMAX-1].join();
			
			
			
			for(int i = 0; i < a.length; i++){
				System.out.println(lol[i].getMyData());
			}
		}catch(Exception e){System.out.println(e);};
		
	}

}

#!/usr/bin/tclsh
set start [clock seconds]
set infile \"\"
set outfile \"\"
set IsOutputSet \"0\"
set fileContent {}
#Ausgabe der Hilfe
proc hilfe {} {
	puts stdout \"Usage: ./wavelet.tcl \\[<opts>\\] <inputfile> \\[<opts>\\]
  Opts are:
    -h, --help:          print this message and exit 0
    -o, --output <file>: output file\"
}


proc getContent {fileID} {
	set tempContent {}
	while {1} { set tempGets [gets $fileID]
			append tempContent $tempGets \" \"
			if {[eof $fileID]} {
				break
			}
	}
	if {[string equal [lindex $tempContent end] \"\"]} {
		set tempContent [lreplace $tempContent end end]
	}
	return $tempContent 
}


proc calcRow {row halfmaxgrey} {
	set averages {}
	set dists {}
	set indx 0
	while {[llength $row] > $indx} {
		set firstValue [lindex $row $indx]
		set average [expr [expr $firstValue + [lindex $row [expr $indx + 1]]] / 2 ]
		lappend averages $average
		lappend dists [expr $halfmaxgrey + $firstValue - $average]
		incr indx 2
	}
	return [concat $averages $dists]
}


proc calcCol {matrix halfmaxgrey} {
	set averages {}
	set dists {}
	set indX 0
	set indY 0
	while {[llength $matrix] > $indY} {
		while {[llength [lindex $matrix $indY]] > $indX} {
			set firstValue [lindex [lindex $matrix $indY] $indX]
			set secondValue [lindex [lindex $matrix [expr $indY + 1]] $indX]
			set average [expr [expr $firstValue + $secondValue] / 2]
			lappend averages $average
			lappend dists [expr $halfmaxgrey + $firstValue - $average]
			incr indX
		}
		set indX 0
		incr indY 2
	}
	return [concat $averages $dists]
}

proc listbuilder {liste colcount rowcount halfmaxgrey} {
	set x1 0
	set indx 0
	set result {}
	while {$x1 < $colcount} {
		set line [lrange $liste $indx [expr [expr $indx + $rowcount] - 1]]
		lappend result [calcRow $line $halfmaxgrey]
		incr x1
		incr indx $rowcount
	}
	return [calcCol $result $halfmaxgrey]
}

proc checkregfile {filename} {
	if {[regexp {^[-]} $filename] != 0} {
		hilfe; exit 1
	}
}

while {[llength $argv] > 0} {
	switch -glob -- [lindex $argv 0] {
		-h - --help  	{ 	hilfe; exit 0 }
		-o - --output  	{	if {[string equal $IsOutputSet \"1\"]} {
						hilfe; puts \"doppelter output\" ;  exit 1 
					}
					set IsOutputSet \"1\"
					set argv [lreplace $argv 0 0]
					checkregfile [ lindex $argv 0 ]
					set outfile [ lindex $argv 0 ]
				}
	
		default 	{	checkregfile [ lindex $argv 0 ]
					if {[ file isfile [lindex $argv 0]]} { 
						set infile [lindex $argv 0] 
			  		} else {
						hilfe; exit 1
			  		}
				}
	}
	set argv [lreplace $argv 0 0]
}

if {[string equal $infile \"\"]} {
	hilfe; puts \"infile nicht gesetzt\" ; exit 1
} else {
	set fileID [open $infile r]
	set fileContent [getContent $fileID]
	set mnumber [lindex $fileContent 0]
	set colnumber [lindex $fileContent 2]
	set rownumber [lindex $fileContent 1]

	if {[expr fmod($colnumber, 2)] != 0 || [expr fmod($rownumber, 2)] != 0} {
		hilfe; exit 1
	}
	set maxgrey [lindex $fileContent 3]
	set halfmaxgrey [expr [expr $maxgrey + 1] / 2 ]
	set fileContent [lreplace $fileContent 0 3]
	set fileContent [listbuilder $fileContent $colnumber $rownumber $halfmaxgrey]
}

set fileID [open $outfile w]
puts $fileID \"$mnumber\"
puts $fileID \"$rownumber $colnumber\" 
puts $fileID \"$maxgrey\"
puts $fileID \"$fileContent\"
#puts \"Laufzeit: [expr [clock seconds] - $start]\"

#define R		0	
#define G		1	
#define B		2	

typedef unsigned char UINT8;
typedef unsigned short int UINT16;


int main(int argc, char **argv)
{
	FILE *input, *output;
	UINT8 rgb_in[3];
	int byte;
	UINT16 rgb_out;

	if(argc != 3)
	{
		exit(EXIT_FAILURE);
	}

	if((input = fopen(argv[1], "rb")) == NULL)
	{
		exit(EXIT_FAILURE);
	}

	if((output = fopen(argv[2], "w+b")) == NULL)
	{
		exit(EXIT_FAILURE);
	}


	while((byte = fgetc(input)) != EOF)
	{
		rgb_in[R] = (UINT8) byte;

		if((byte = fgetc(input)) == EOF)
		{
			exit(EXIT_FAILURE);
		}

		rgb_in[G] = (UINT8) byte;

		if((byte = fgetc(input)) == EOF)
		{
			exit(EXIT_FAILURE);
		}

		rgb_in[B] = (UINT8) byte;

		rgb_in[R] = rgb_in[R] >> 3;
		rgb_in[G] = rgb_in[G] >> 3;
		rgb_in[B] = rgb_in[B] >> 3;

		rgb_out = ((UINT16) rgb_in[R] << 10) | ((UINT16) rgb_in[G] << 5) | ((UINT16) rgb_in[B]);

		fputc(((rgb_out & 0xFF00) >> 8), output);
		fputc((rgb_out & 0x00FF), output);
	}

	fclose(input);
	fclose(output);

	return 0;
}

Bla   
                   
                        
                                
                         
                                  
                                
                                  
                    
          
                                                
                                
                          
                                 
             
                                        
                                                
                  
           
                                                
                                
                                 
                                 
                                  
                                        
                  
          
                                  
                
                                        
                        
                                         
                 
                                                
    
        
             

        

                         

                 
        
        
           

        

         
Blub