Report Hello_World.
Write: "Hello World".

WRITE "Hello World"

FOR i IN {1..10}
   WRITE i*i

-- Hello World
with Text_IO;
use Text_IO;

procedure HelloWorld is
begin
   Put_Line("Hello World");
end HelloWorld;

-- Hello World
with Ada.Text_IO;
use Ada.Text_IO;

procedure HelloWorld is
begin
   Put_Line("Hello World");
end HelloWorld;

-- File:   oo.ads
-- Author: Michael Neumann

package OO is

   type Byte is range 0 .. 255;
   for Byte'Size use 8;

   type Color is
      record
         Red,
         Green,
         Blue  : Byte;
      end record;

   type Shape is abstract tagged
      record
         X,
         Y : Integer;
         C : Color;
      end record;

   type Circle is new Shape with
      record
         Radius : Integer;
      end record;

   type Rectangle is new Shape with
      record
         Width,
         Height : Integer;
      end record;

   procedure Move (
         Self : in out Shape'Class;
         DX,
         DY    :        Integer      );

   procedure Draw (
         Self : in     Circle'Class );


   procedure Draw (
         Self : in     Rectangle'Class );

   function Get_Area (
         Self : in     Circle'Class )
     return Integer;


   function Get_Area (
         Self : in     Rectangle'Class )
     return Integer;

end OO;

-- File:   oo.adb
-- Author: Michael Neumann

package body OO is

   procedure Move (
         Self : in out Shape'Class;
         DX,
         DY   :        Integer      ) is
   begin
      Self.X := Self.X + DX;
      Self.Y := Self.Y + DY;
   end Move;

   procedure Draw (
         Self : in     Circle'Class ) is
   begin
      -- Do something here      
      null;
   end Draw;

   procedure Draw (
         Self : in     Rectangle'Class ) is
   begin
      -- Do something here
      null;
   end Draw;


   function Get_Area (
         Self : in     Circle'Class )
     return Integer is
      Pi : constant Float := 3.1415;
   begin
      return Integer( Pi * Float(Self.Radius) );
   end;

   function Get_Area (
         Self : in     Rectangle'Class )
     return Integer is
   begin
      return Self.Width * Self.Height;
   end;

end OO;

-- File:   oo_test.adb
-- Author: Michael Neumann

with Ada.Text_IO, OO;
use Ada.Text_IO, OO;

procedure OO_Test is
   package MyInt is new Integer_IO(Integer);
   use MyInt;

   BLACK : constant Color := (0, 0, 0);
   WHITE : constant Color := (255, 255, 255);

   Circ : Circle;
   Rect : Rectangle;
begin

   Circ := Circle'(
      X      => 100,
      Y      => 100,
      Radius => 50,
      C      => BLACK);

   Rect := Rectangle'(
      X      => 20,
      Y      => 20,
      Width  => 5,
      Height => 5,
      C      => WHITE);

   Move(Circ, DY => 10, DX => 10);
   Circ.X := 50;
   Circ.Radius := 5;

   Put( Get_Area(Circ) ); -- => 16 (Ada always rounds numbers up)
   Put( Get_Area(Rect) ); -- => 25

   Put( Rect.Width ); -- => 5
   Rect.Width := 10;
   Put( Rect.Width ); -- => 10

   Draw(Circ);
   Draw(Rect);
end;

with Ada.Text_IO; 

procedure Squares is
use Ada.Text_IO;
package MyInt is new Integer_IO(Integer);
begin
   for I in 1..10 loop
      MyInt.Put(I*I);
      Put(" ");
   end loop;
   New_Line;
end Squares;

trans fac (n) (
   if (> n 1) (* n (fac (- n 1))) 1
)

println (fac 6)

# Hello World in Aleph

println "Hello World"

# deklariere Variable
trans index 1

while (< index 11) {
   println (* index index) " "
}

# Hello World in Algae

printf("Hello World\n");

# fill(shape; values)
fill(3,4; 1,2,3,4)   # => 3x4 matrix filled (row-wise) with 1,2,3,4

diag(1,2,3) # 3x3 matix with 1,2,3 on the diagonal

# linspace(a; b; n)
linspace(1;10;100)  creates a vector with 100 elements from 1 to 10

# ident(n)
# creates the nxn identity matrix

# Note that functions can be applied to scalars as well as to vectors or matrices
squares = function(x)
{
  return x^2;
}

nums = 1:10:1;    # a vector containing elements from 1 to 10

print( squares(nums) );
# or ...
print( nums^2 );

for (i in 1:10) {
  printf("%d "; i^2);
}
printf("\n");

'begin'
   outstring(2, 'Hello World');
'end'

'begin'
   'string'  s := 'Hello World';
   'integer' i;

   'for' i := 1 'step' 1 'until' length(s) 'do' outsymbol(2,s,i);
'end'

'begin' 'comment' gibt die Quadrate von 1 bis 10 aus;
   'integer' i;

   'for' i := 1 'step' 1 'until' 10 'do'
   'begin'
      outinteger(2,i*i);
   'end' --for-----diese Schleife gibt die Quadrate aus
'end' --Ende des Programmes

PRINT "Hello World"

<%@ language="javascript" %>
<html><body>
<%
  Response.Write('Hello World!');
%>
</body></html>

<%@ language="vbscript" %>
<html><body>
<%
  Response.write "Hello World!"
%>
</body></html>

; Uses S-C Assembler variant.
; .or is origin
; .as is ASCII String
; .hs is Hex String
        .or $300
main    ldy #$00
.1      lda str,y
        beq .2
        jsr $fded ; ROM routine, COUT, y is preserved
        iny
        bne .1
.2      rts
str     .as "HELLO WORLD"
        .hs 0D00

TITLE 'Hello World for IBM Assembler/370 (VM/CMS)'
HELLO    START
         BALR  12,0
         USING *,12
*
         WRTERM 'Hello World!'
*
         SR    15,15
         BR    14
*
END   HELLO

         TITLE 'Squares from 1 to 10 - IBM Assembler/370 (VM/CMS)'
*
SQUARE   START
         BALR  12,0
         USING *,12
*
         LA    4,1                * Start value = 1
         LR    2,4                * Increment by 1
         LA    3,10               * Range value = 10
*
LOOP     EQU   *
         LR    7,4                * Copy the loop value
         MR    6,7                * Multiply by itself
*
         CVD   7,DW               * Convert it to decimal
         MVC   WORKAREA,PATTERN   * Copy edit pattern
         EDMK  WORKAREA,DW        * Convert decimal value to character
         WRTERM WORKAREA,16       * Display
*
         BXLE  4,2,LOOP           * Iterate until R4 <= R3
*
         SR    15,15
         BR    14
*
DW       DS    D
WORKAREA DS    XL16
PATTERN  DC    X'40202020202020202020202020202120'
*
         END   SQUARE

.MODEL tiny
.CODE
        ORG 100h
HELLO          PROC
        MOV     AH,09h
        LEA     DX,msg
        INT     21h                     ;Display Hello World

        MOV     AX,4C00h                ;Exit to DOS
        INT     21h
HELLO          ENDP
        msg     DB      'Hello World$'
        END     HELLO

; WRITTEN IN TASM (Turbo Assembler)
.MODEL TINY
CODE SEGMENT
ASSUME CS:CODE, DS:CODE
ORG 100h
START:
        mov ah,9
        mov dx,OFFSET Msg
        int 21h
        int 20h
        Msg DB 'Hello World',13,10,'$'
CODE ENDS
END START 

/*
 *  Hello World in gas/NetBSD
 *  AT/T-Syntax
 *
 *  Compile:
 *    gas hw.s 
 *    ld -s -o hw a.out
 */

.data

msg:
    .string "Hello World\n"
  
len: 
    .long . - msg


.text
.globl _start

_start:
    push $len        /* Laenge */
    push $msg        /* Adresse */
    push $1          /* Stdout */
    movl $0x4, %eax  /* write */
    call _syscall
    addl $12, %esp   /* Stack bereinigen */

    push $0
    movl $0x1, %eax  /* exit */
    call _syscall
  
_syscall:
    int  $0x80
    ret

;
; Hello World in nasm/NetBSD(aout)
;

; Compile:
;    nasm -f aoutb hw.asm
;    ld -s -o hw hw.o

section .text


_start:
    push    dword len    ; Länge
    push    dword msg    ; Adresse
    push    dword 1      ; Stdout
    mov     eax, 0x4     ; write
    call    _syscall
    add     esp, 12      ; Stack bereinigen

    push    dword 0
    mov     eax, 0x1     ; exit
    call    _syscall

_syscall:
    int     0x80
    ret

msg db      "Hello World",0xa
len equ     $ - msg

;;
;; A Fast and Good Hash Function
;;
;; Algorithm by Bob Jenkins, December 1996
;; (see http://burtleburtle.net/bob/c/lookupa.c for C version)
;;
;; Implemented by Michael Neumann, June 2002.
;;
;; Requires NASM - the Netwide Assembler.
;;

global s_lookup
section .text

%macro mix_line 6
        ;;; parameters: r x y shift temp direction(left|right)
        ;;; r -= x; r -= y; r ^= (y(>>|<<)shift)

        ; r -= x
        sub %1, %2

        ; r -= y
        sub %1, %3

        ; r ^= (y>>shift)
        mov %5, %3
%ifidni %6,left
        shl %5, %4
%else
        shr %5, %4
%endif
        xor %1, %5
%endmacro

%macro mix 4
        ;;; parameters: a b c temp

        ;;;a -= b; a -= c; a ^= (c>>13); 
        mix_line %1, %2, %3, 13, %4, right

        ;;;b -= c; b -= a; b ^= (a<<8); 
        mix_line %2, %3, %1, 8, %4, left

        ;;;c -= a; c -= b; c ^= (b>>13); 
        mix_line %3, %1, %2, 13, %4, right

        ;;;a -= b; a -= c; a ^= (c>>12);  
        mix_line %1, %2, %3, 12, %4, right

        ;;;b -= c; b -= a; b ^= (a<<16); 
        mix_line %2, %3, %1, 16, %4, left

        ;;;c -= a; c -= b; c ^= (b>>5); 
        mix_line %3, %1, %2, 5, %4, right

        ;;;a -= b; a -= c; a ^= (c>>3);  
        mix_line %1, %2, %3, 3, %4, right

        ;;;b -= c; b -= a; b ^= (a<<10); 
        mix_line %2, %3, %1, 10, %4, left

        ;;;c -= a; c -= b; c ^= (b>>15); 
        mix_line %3, %1, %2, 15, %4, right
%endmacro

jump_table: dd case0, case1, case2, case3, case4, case5, case6, case7, case8, case9, case10, case11

; unsigned long s_lookup(void *key, int length, int level)
s_lookup:

%define temp edx        ; temporary register: edx
%define a ecx           ; a 
%define b ebx           ; b
%define c eax           ; c
%define len edi         ; len
%define key esi         ; key

        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        push    ebx
        push    ecx
        push    edx
        ; --------------------------------------------------------

        mov     key, [ebp+8]            ; first argument (key)

        ; Set up the internal state

        ;;; len = length
        mov     len, [ebp+12]           ; second argument (length)

        ;;; a = b = 0x9e3779b9 
        mov     a, 9e3779b9h
        mov     b, a

        ;;; c = level
        mov     c, [ebp+16]

        ;;; while (len >= 12)
while:
        cmp len, 12
        jl near end_while                  ; exit if len < 12

        ;;; a += (k[0] +((ub4)k[1]<<8) +((ub4)k[2]<<16) +((ub4)k[3]<<24));
        add a, [key]

        ;;; b += (k[4] +((ub4)k[5]<<8) +((ub4)k[6]<<16) +((ub4)k[7]<<24));
        add b, [key+4]

        ;;; c += (k[8] +((ub4)k[9]<<8) +((ub4)k[10]<<16)+((ub4)k[11]<<24));
        add c, [key+8]

        mix a, b, c, temp

        add key, 12
        sub len, 12

        jmp near while

end_while:

        ;;; c += length;
        add c, [ebp+12]


;; jump table

        jmp [jump_table+len*4]

case11:
        add a, [key]       ; cases 1,2,3,4
        add b, [key+4]     ; cases 5,6,7,8
        mov temp, [key+8]  ; cases 9,10,11
        shl temp, 8
        add c, temp
        jmp ende

case10:
        add a, [key]       ; cases 1,2,3,4
        add b, [key+4]     ; cases 5,6,7,8
        mov temp, [key+8]  ; cases 9,10
        shl temp, 8
        and temp, 0FFFFFFh
        add c, temp
        jmp ende

case9:
        add a, [key]       ; cases 1,2,3,4
        add b, [key+4]     ; cases 5,6,7,8
        mov temp, [key+8]  ; cases 9
        shl temp, 8
        and temp, 0FFFFh
        add c, temp
        jmp ende

case8:
        add a, [key]     ; cases 1,2,3,4
        add b, [key+4]   ; cases 5,6,7,8
        jmp ende

case7:
        add a, [key]       ; cases 1,2,3,4
        mov temp, [key+4]  ; cases 5,6,7
        and temp, 0FFFFFFh
        add b, temp
        jmp ende

case6:
        add a, [key]       ; cases 1,2,3,4
        mov temp, [key+4]  ; cases 5,6
        and temp, 0FFFFh
        add b, temp
        jmp ende

case5:
        add a, [key]       ; cases 1,2,3,4
        mov temp, [key+4]  ; cases 5
        and temp, 0FFh
        add b, temp
        jmp ende

case3:
        mov temp, [key]
        and temp, 0FFFFFFh
        add a, temp        ; cases 1,2,3
        jmp ende

case2:
        mov temp, [key]
        and temp, 0FFFFh
        add a, temp        ; cases 1,2
        jmp ende

case1:
        mov temp, [key]
        and temp, 0FFh
        add a, temp        ; cases 1
        jmp ende

;; the last case should be the most often occuring one (so we can save one jump instruction)
case4:
        add a, [key]       ; cases 1,2,3,4

case0:
ende:

        mix a, b, c, temp


        ; return value in eax
%ifnidni c,eax
        mov eax, c
%endif

        ; --------------------------------------------------------
        pop     edx
        pop     ecx
        pop     ebx
        pop     edi
        pop     esi
        pop     ebp
        ret

;; Hello world in MIDAS

title   hello

start:  .open   [.uao,,'tty ? 0 ? 0]
         .lose  %lsfil
        move    1, [440700,,[asciz "Hello, world
"]]
loop:   ildb    2,1
        skipn   2
         .logou 1,
        .iot    2
        jrst    loop

end     start

;; Squares of integers 1..10 in MIDAS

title   squares

p==17
.vector pdl(lpdl==200)
ttyo==:5

start:  move    p, [-lpdl,,pdl-1]
        .open   ttyo, [.uao,,'tty ? 0 ? 0]
         .lose  %lsfil
        move    1, [-12,,1]
loop:   hrrz    2, 1
        imul    2, 2
        pushj   p, print
        movei   2, 15
        .iot    ttyo, 2
        movei   2, 12
        .iot    ttyo, 2
        aobjn   1, loop
        .logou  1,

print:  idivi   2, 12
        push    p, 3
        skipe   2
         pushj  p, print
        pop     p, 2
        addi    2, "0
        .iot    ttyo, 2
        popj    p,

end     start

.data                     # Datensegment
str:    .asciiz "Hello World!\n"  # String ablegen
        .text                     # Codesegment
main:   li      $v0, 4            # 4 = Print_string
        la      $a0, str          # Adresse des Strings übergeben
        syscall                   # Systemfunktion aufrufen
        li      $v0, 10           # 10 = Quit
        syscall                   # Programm beenden

start:
        ; Message-String ausgeben
        move.l #msg,-(a7)
        move.w #9,-(a7)
        trap #1
        addq.l #6,a7

        ; auf Taste warten
        move.w #1,-(a7)
        trap #1
        addq.l  #2,a7

        ; Programm beenden
        clr -(a7)
        trap #1
         
        msg: dc.b "Hello World",10,13,0

LL0:
        .data
        .text
L       .align  1
        .globl  _main
_main:
        .word   L12
        jbr     L14
L15:
        .data   1
L17:
        .ascii  "Hello, world.2"
        .text
        pushl   $L17
        calls   $1,_puts
        ret
        .set    L12,0x0
L14:
        jbr     L15
        .data

#
# Hello World in awk
#

BEGIN {
  print "Hello World"
}

function sqr(n) {
  return n*n
}

BEGIN {
  for(i=1; i<=10; i++) {
    printf "%d ", sqr(i) 
  }
  print    # new line
}

PRINT "Hello World"

FOR I=1 TO 10
   PRINT I*I;
NEXT I

// BCPL 'Hello World' program

GET "LIBHDR"

LET START () BE
$(
    WRITES ("Hello World!*N")
$)               

55+82+*99*88*77*66*55*44*33*22*11*>v
                                  .:
                                  ^_@

a987654321>v
          .:
          *v
          :v
          ^_@

(#
do
   'Hello World' -> putline
#)

(#
   schleife:  (# n: @integer
              enter n
              do (for n repeat inner for)
              #)
do
   9 -> schleife  (#
                  do 10-n -> schleife (#
                                      do n -> putint; ' ' -> put
                                      #) newline
                  #)
#)

(#
do
   (for i:10 repeat
      i*i -> putint
   for)
#)

-- Hello World in Blue

class HelloWorld is
==
== HelloWorld-Klasse
==
     
interface
   
    creation is
      == Erzeugt das HelloWorld-Objekt
      do
        printIt
      end creation

  routines

    printIt is
      == prints Hello World
      do
        print("Hello World\n")
      end printIt

end class

fac = {|n|
  (n > 1) if-true:  { n * fac (n-1) }
          if-false: { 1 }.
}.

-- call the code-block and output the value

fac (6); println. 

-- Hello World in Brain
#! this is also a single line comment
{- and a multi-liine
   comment. -}
  
"Hello World" println.

#! Squares in Brain

1 to: 10 by: 1 do: { | i | (i * i) println. }

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.---.+++++++..+++.>++++++++++++++++++++++++++++++++.<++++++++.--------.+
++.------.--------.>+.>++++++++++.

+[>+[>+<-]<-] >> [>+<-]>[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<
-]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>
>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-
<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<
+>>-]<<-]>++++[<++++++++>-]<.[-] ++[>++[>+<-]<-] >> [>+<-]>[[>+>+<<-]>>[
<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>-]<<-<-]++++
+++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]
<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+
<-]+++++++[<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<++++++++>-]<.[-] +++[
>+++[>+<-]<-] >> [>+<-]>[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<
-]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>
>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-
<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<
+>>-]<<-]>++++[<++++++++>-]<.[-] ++++[>++++[>+<-]<-] >> [>+<-]>[[>+>+<<-
]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>-]<<-<-]
+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>+++++++++<[>>>+<<[>+
>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<
[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<++++++++>-]<.[-]
+++++[>+++++[>+<-]<-] >> [>+<-]>[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[
>+>[-]<<-]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<
[>+<-]>>>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>
>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.
[-]>>[<<+>>-]<<-]>++++[<++++++++>-]<.[-] ++++++[>++++++[>+<-]<-] >> [>+<
-]>[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++
++>>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>++++++++
+<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<
<<>[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<+++++
+++>-]<.[-] +++++++[>+++++++[>+<-]<-] >> [>+<-]>[[>+>+<<-]>>[<<+>>-]<>++
+++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<->-
]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]
>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++++[
<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<++++++++>-]<.[-] ++++++++[>+++++
+++[>+<-]<-] >> [>+<-]>[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<-
]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>>
[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-<
-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<+
>>-]<<-]>++++[<++++++++>-]<.[-] +++++++++[>+++++++++[>+<-]<-] >> [>+<-]>
[[>+>+<<-]>>[<<+>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>
>-]<<-<-]+++++++++>[<->-]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>+++++++++<[
>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>
[-]<<+>]<[[>+<-]+++++++[<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<++++++++
>-]<.[-] ++++++++++[>++++++++++[>+<-]<-] >> [>+<-]>[[>+>+<<-]>>[<<+>>-]<
>+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>-]<<-<-]+++++++++>[<
->-]<[>+<-]<[>+<-]<[>+<-]>>>[<<<+>>>-]<>+++++++++<[>>>+<<[>+>[-]<<-]>[<+
>-]>[<<++++++++++>>>+<-]<<-<-]>>>>[<<<<+>>>>-]<<<<>[-]<<+>]<[[>+<-]+++++
++[<+++++++>-]<-><.[-]>>[<<+>>-]<<-]>++++[<++++++++>-]<.[-]

/*
 * Calculating PI
 *
 * Author: Michael Neumann (mneumann@fantasy-coders.de)
 * Date: 03.12.2002
 *
 * Requires GNU MP (tested with version 4.1) 
 * (http://www.swox.com/gmp/)
 *
 * To compile:
 *   cc pi.c -o pi -I/usr/local/include -L/usr/local/lib -lgmp
 */

#include "gmp.h"
#include <stdio.h>

int main(int argc, char **argv) {
  mpz_t k, a, b, a1, b1, p, q, d, d1;
  mpz_t t1, t2, t3, t4;  /* temporary */

  /* Initialize and assign integers */

  mpz_init(p);
  mpz_init(q);
  mpz_init(d);
  mpz_init(d1);
  mpz_init(t1);
  mpz_init(t2);
  mpz_init(t3);
  mpz_init(t4);
  mpz_init_set_ui(k, 2);
  mpz_init_set_ui(a, 4);
  mpz_init_set_ui(b, 1);
  mpz_init_set_ui(a1, 12);
  mpz_init_set_ui(b1, 4);

  for(;;) {
    /* Next approximation */

    mpz_mul(p, k, k);                   /* p = k * k */
    mpz_mul_ui(q, k, 2);                /* q = k * 2 */
    mpz_add_ui(q, q, 1);                /* q = q + 1 */
    mpz_add_ui(k, k, 1);                /* k = k + 1 */

    mpz_set(t1, a1);                    /* t1 = a1 */
    mpz_set(t2, b1);                    /* t2 = b1 */

    /* a1 = p*a + q*a1 */
    mpz_mul(t3, p, a);                  /* t3 = p * a */
    mpz_mul(t4, q, a1);                 /* t4 = q * a1 */
    mpz_add(a1, t3, t4);                /* a1 = t3 + t4 */

    /* b1 = p*b + q*b1 */
    mpz_mul(t3, p, b);                  /* t3 = p * b */
    mpz_mul(t4, q, b1);                 /* t4 = q * b1 */
    mpz_add(b1, t3, t4);                /* b1 = t3 + t4 */

    mpz_set(a, t1);
    mpz_set(b, t2);

    /* Print common digits */

    mpz_tdiv_q(d, a, b);                /* d = a / b */
    mpz_tdiv_q(d1, a1, b1);             /* d1 = a1 / b1 */

    while (mpz_cmp(d, d1) == 0) {       /* d == d1 */
      mpz_out_str(stdout, 10, d1);
      fflush(stdout);

      /* a = 10*(a mod b) */
      mpz_tdiv_r(t1, a, b);             /* t1 = a mod b */
      mpz_mul_si(a, t1, 10);            /* a = t1 * 10 */

      /* a1 = 10*(a1 mod b1) */
      mpz_tdiv_r(t1, a1, b1);           /* t1 = a1 mod b1 */
      mpz_mul_si(a1, t1, 10);           /* a = t1 * 10 */

      mpz_tdiv_q(d, a, b);              /* d = a / b */
      mpz_tdiv_q(d1, a1, b1);           /* d1 = a1 / b1 */
    }
  }

  return 0;
}

#include <stdio.h>

main() {
   printf("Hello World\n");
}

/*
 * $Id: echo-mt.c,v 1.1 2002/01/09 14:28:43 michael Exp $
 *
 * Copyright (c) 2001, 2002 by Michael Neumann
 *
 * Multiple Threaded (forking) Echo-Server.
 *
 * Platform: NetBSD (should run on other Unices, too).
 *
 */

#include <sys/types.h>     /* htons() ... */
#include <sys/socket.h>    /* socket(), bind(), listen(), accept() */
#include <netinet/in.h>    /* sockaddr_in */

#include <sys/param.h>     /* MAXHOSTNAMELEN */
#include <netdb.h>         /* gethostbyname() */

#include <signal.h>        /* signal() */
#include <sys/wait.h>      /* waitpid() */

#include <unistd.h>        /* close(), gethostname(), read() ... */
#include <stdio.h>         /* perror() */
#include <strings.h>       /* bzero(), bcopy() */

#define PORT_NR 8000       /* port number to listen on */


/** 
 * Signal handler for SIGCHLD (child process changes state).
 *
 * Queries return status of terminated child processes, 
 * otherwise zombie processes will occure.
 */
void child_sig_handler(void) {
 while (waitpid(-1, NULL, WNOHANG) > 0)
   ;
}


int main(int argc, char** argv) {
  int s, t;                /* socket handles */
  struct sockaddr_in sa;   /* socket address */
  char myhostname[MAXHOSTNAMELEN+1]; /* local host name */
  struct hostent *hp;      /* host informations */

  int pid;      /* proccess id of forked child process */

  int count;
  char buffer[100];

  /* get host informations */
  gethostname(myhostname, MAXHOSTNAMELEN);
  if ( (hp = gethostbyname(myhostname)) == NULL ) {
    perror("Couldn't get informations about host name.");
    return -1;
  }

  /* initialize sockaddr_in struct */
  bzero(&sa, sizeof (struct sockaddr_in));
  bcopy(hp->h_addr, &sa.sin_addr, hp->h_length);
  sa.sin_family = hp->h_addrtype;
  sa.sin_port = htons(PORT_NR);

  /* create socket */
  if ( (s = socket(PF_INET, SOCK_STREAM, 0)) == -1 ) {
    perror("Couldn't create socket.");
    return -1;
  }

  /* bind socket `s' to specific address (local host) */
  if ( bind(s, (struct sockaddr*) &sa, sizeof (struct sockaddr)) == -1 ) {
    perror("Coudn't bind socket.");
    close(s);
    return -1;
  }

  /* allow incoming requests; queue up to 3 of them */
  listen(s, 3);


  /* install signal handler */
  signal(SIGCHLD, child_sig_handler);


  while (1) {

    /* accept a connection */
    if ( (t = accept(s, NULL, NULL)) == -1 ) {
      perror("Couldn't accept socket.");
      close(s);
      return -1;
    }

    /* fork new subprocess, which handles the new connection */
    switch (pid = fork()) {
    case -1:  /* error */
      perror("Could not fork!");
      close(s);
      close(t);
      return -1;

    case 0:   /* child process */
      /* close handle `s' as it is a duplicate */
      close(s);

      /* echo data */
      while ( (count = read(t, buffer, sizeof (buffer)-1)) > 0 ) {
         write(t, buffer, count);
      }

      /* close connection */
      close(t);
      return 0;

    default:  /* parent process */
      /* close handle `t' as it is a duplicate */
      close(t);
    }

  }

  close(s);
  return 0;
}

/*
 * $Id: echo-st.c,v 1.2 2002/01/09 14:29:03 michael Exp $
 *
 * Copyright (c) 2001, 2002 by Michael Neumann
 *
 * Single Threaded (non-forking) Echo-Server.
 *
 * Platform: NetBSD (should run on other Unices, too).
 *
 */

#include <sys/types.h>     /* htons() ... */
#include <sys/socket.h>    /* socket(), bind(), listen(), accept() */
#include <netinet/in.h>    /* sockaddr_in */

#include <sys/param.h>     /* MAXHOSTNAMELEN */
#include <netdb.h>         /* gethostbyname() */

#include <unistd.h>        /* close(), gethostname(), read() ... */
#include <stdio.h>         /* perror() */
#include <strings.h>       /* bzero(), bcopy() */

#define PORT_NR 8000       /* port number to listen on */


int main(int argc, char** argv) {
  int s, t;                /* socket handles */
  struct sockaddr_in sa;   /* socket address */
  char myhostname[MAXHOSTNAMELEN+1]; /* local host name */
  struct hostent *hp;      /* host informations */

  int count;
  char buffer[100];

  /* get host informations */
  gethostname(myhostname, MAXHOSTNAMELEN);
  if ( (hp = gethostbyname(myhostname)) == NULL ) {
    perror("Couldn't get informations about host name.");
    return -1;
  }

  /* initialize sockaddr_in struct */
  bzero(&sa, sizeof (struct sockaddr_in));
  bcopy(hp->h_addr, &sa.sin_addr, hp->h_length);
  sa.sin_family = hp->h_addrtype;
  sa.sin_port = htons(PORT_NR);

  /* create socket */
  if ( (s = socket(PF_INET, SOCK_STREAM, 0)) == -1 ) {
    perror("Couldn't create socket.");
    return -1;
  }

  /* bind socket `s' to specific address (local host) */
  if ( bind(s, (struct sockaddr*) &sa, sizeof (struct sockaddr)) == -1 ) {
    perror("Coudn't bind socket.");
    close(s);
    return -1;
  }

  /* allow incoming requests; queue up to 3 of them */
  listen(s, 3);

  while (1) {

    /* accept a connection */
    if ( (t = accept(s, NULL, NULL)) == -1 ) {
      perror("Couldn't accept socket.");
      close(s);
      return -1;
    }

    /* echo data */
    while ( (count = read(t, buffer, sizeof (buffer)-1)) > 0 ) {
       write(t, buffer, count);
    }

    /* close connection */
    close(t);
  }

  close(s);
  return 0;
}

// Hello World in C#

using System;
class HelloWorld {
   static void Main() {
      Console.WriteLine("Hello World");
   }
}

using System;
class Squares1 {
   static void Main() {
      for (int i=1; i<=10; i++) {
         Console.WriteLine("{0} ", i*i);
      }
   }
}

using System;
class Squares2 {
   static void Main() {
      string res = "";
      int[] arr  = {1,2,3,4,5,6,7,8,9,10}; // short form for "new int[] = {1,2,...}"
      
      for (int i=0; i<arr.Length; i++) {
         res += (arr[i]*arr[i]).ToString() + " ";
      }
      Console.WriteLine("{0}", res);
   }
}

/*
 *  Boyer-Moore Search
 *
 *  01.06.1998, implemented by Michael Neumann
 */

# include <algorithm>

int BoyerMooreSearch(char* text, char* muster, int tlen, int mlen)
{
  int i, j, skip[256];

  for(i=0; i<256; ++i)  skip[i]=mlen;
  for(i=0; i<mlen; ++i) skip[muster[i]]=mlen-1-i;

  for(i=j=mlen-1; j>=0; --i, --j)
    while(text[i] != muster[j]) {
      i += max(mlen-j,skip[text[i]]);
      if(i >= tlen) return -1;
      j = mlen-1;
    }
  return i;
}

/*
 *  BubbleSort
 *
 *  20.11.1998, implemented by Michael Neumann (mneumann@ntecs.de)
 */

# ifndef __BUBBLESORT_HEADER__
# define __BUBBLESORT_HEADER__

# include <algorithm>

template <class itemType, class indexType=int>
void BubbleSort(itemType a[], indexType l, indexType r)
{
  static indexType i, j;

  for(i=r; i>l; --i)
    for(j=l; j<i; ++j)
      if(a[j] > a[j+1]) std::swap(a[j], a[j+1]);
}

# endif

/*
 *  BucketSort (Distrubution Counting)
 *
 *  21.11.1998, implemented by Michael Neumann (mneumann@ntecs.de)
 */

# ifndef __BUCKETSORT_HEADER__
# define __BUCKETSORT_HEADER__

# include <algorithm>


// itemType must have an typecast to "int", which identifies the sortkey
template <class itemType, class indexType=int>
class BucketSort {
  public:

    // the array b[] had to be the same size like a[]
    void Sort(itemType a[], itemType b[], indexType l, indexType r) {
      a = &a[l]; b = &b[l];
      for(int i=0; i<sizeof(int); ++i) {
        sort_byte(i,a,b,r-l+1);
        std::swap(a,b);
      }
    }

  protected:

    sort_byte(int bytenr, itemType a[], itemType b[], indexType count) {
      static indexType i;
      typedef unsigned char* UCP;

      for(i=0; i<256; ++i) occurences[i] = 0;   // better: memset
      for(i=0; i<count; ++i) ++occurences[((UCP)&a[i])[bytenr]];
      for(i=1; i<256; ++i) occurences[i] += occurences[i-1];
      for(i=count-1; i>=0; --i)
        b[--occurences[((UCP)&a[i])[bytenr]]] = a[i];
    }

    int occurences[256];
};

# endif

/*
    Größter Gemeinsamer Teiler

    Es sind nur Werte größer als Null zulässig.
*/

int ggt( int a, int b )
{
  int temp;
  if( a < b ) { temp=a; a=b; b=temp; }
  while( (temp = a%b) != 0 )
  {
    a = b;
    b = temp;
  };
  return b;
}

/*
 *  Hash1.Cpp
 *
 *  03.06.1998, implemented by Michael Neumann
 */

int hash1(int M, char* t)
{
  unsigned h=0;
  for(;*t;++t) h = ((h << 8)+ *t) % M;
  return h;
}

/*
 *  hashpjw, algorithm by P.J.Weinberg
 *
 *  03.06.1998, implemented by Michael Neumann
 */

int hashpjw(int M, char* t)
{
  unsigned h=0, g;
  for(;*t;++t) {
    h = (h << 4)+ *t;
    if(g=h&0xf0000000) {
      h ^= g>>24;
      h ^= g;
    }
  }
  return h%M;
}

#include <stdio.h>

int main(int argc, char *argv[])
{
   printf("Hello World\n");
   return 0;
}

#include <iostream.h>

int main(int argc, char *argv[])
{
   cout << "Hello World" << endl;
   return 0;
}

#include <iostream>
using namespace std;

int main()
{
   cout << "Hello World" << endl;
   return 0;
}

/*
 *  InsertionSort
 *
 *  20.11.1998, implemented by Michael Neumann (mneumann@ntecs.de)
 */

# ifndef __INSERTIONSORT_HEADER__
# define __INSERTIONSORT_HEADER__

# include <algorithm>

template <class itemType, class indexType=int>
void InsertionSort(itemType a[], indexType l, indexType r)
{
  static indexType i, j;
  static itemType v;

  for(i=l+1; i<=r; ++i) {
    for(j=i-1, v=a[i]; j>=l && a[j]>v; a[j+1]=a[j], --j);
    a[j+1] = v;
  }
}

# endif

/*
 *  MergeSort
 *
 *  21.11.1998, implemented by Michael Neumann (mneumann@ntecs.de)
 */

# ifndef __MERGESORT_HEADER__
# define __MERGESORT_HEADER__

# include <algorithm>

// Array b[] must have same size like a[]; result is in a[]!
template <class itemType, class indexType=int>
void MergeSort(itemType a[], itemType b[], indexType l, indexType r)
{
  indexType i, j, k, m;

  if(r > l) {
    m = (r+l)/2;
    MergeSort(a,b,l,m);
    MergeSort(a,b,m+1,r);
    for(i=m+1; i>l; --i) b[i-1] = a[i-1];
    for(j=m; j<r; ++j) b[r+m-j] = a[j+1];
    for(k=l; k<=r; ++k) a[k] = (b[i] < b[j]) ?  b[i++] : b[j--];
  }
}

# endif

/*
 *  QuickSort, algorithm by C.A.R. Hoare (1960)
 *
 *  01.06.1998, implemented by Michael Neumann (mneumann@ntecs.de)
 */

# ifndef __QUICKSORT_HEADER__
# define __QUICKSORT_HEADER__

# include <algorithm>

template <class itemType, class indexType=int>
void QuickSort(itemType a[], indexType l, indexType r)
{
  static itemType m;
  static indexType j;
  indexType i;

  if(r > l) {
    m = a[r]; i = l-1; j = r;
    for(;;) {
      while(a[++i] < m);
      while(a[--j] > m);
      if(i >= j) break;
      std::swap(a[i], a[j]);
    }
    std::swap(a[i],a[r]);
    QuickSort(a,l,i-1);
    QuickSort(a,i+1,r);
  }
}

# endif

/*
 *  SelectionSort
 *
 *  20.11.1998, implemented by Michael Neumann (mneumann@ntecs.de)
 */

# ifndef __SELECTIONSORT_HEADER__
# define __SELECTIONSORT_HEADER__

# include <algorithm>

template <class itemType, class indexType=int>
void SelectionSort(itemType a[], indexType l, indexType r)
{
  static indexType i, j, min;

  for(i=l; i<r; ++i) {
    for(min=i, j=i+1; j<=r; ++j) if(a[j] < a[min]) min = j;
    std::swap(a[min], a[i]);
  }
}

# endif

/*
 *  ShellSort
 *
 *  20.11.1998, implemented by Michael Neumann (mneumann@ntecs.de)
 */

# ifndef __SHELLSORT_HEADER__
# define __SHELLSORT_HEADER__

# include <algorithm>

template <class itemType, class indexType=int>
void ShellSort(itemType a[], indexType l, indexType r)
{
  static indexType i, j, h;
  static itemType v;

  for(h=1; h<=(r-l)/9; h=3*h+1);
  for(; h>0; h/=3) {
    for(i=l+h; i<=r; ++i) {
      for(j=i-h, v=a[i]; j>=l && a[j]>v; a[j+h]=a[j], j-=h);
      a[j+h] = v;
    }
  }
}

# endif

#include <stdio.h>

void main()
{
   printf("Hello World\n");
}

#include <iostream.h>

void main()
{
   cout << "Hello World" << endl;
}

#include <stdio.h>

cilk void main()
{
   printf("Hello World\n");
}

/* Cilk ist fast C */

#include <stdio.h>

cilk void main()
{
   int i;
   
   for(i = 1; i <= 10; ++i) printf("%d ", i*i);   
}

;; Hello World in CLAIRE

[ main() -> printf("Hello World\n") ]

[

main() ->
   for i in (1 .. 10) printf("~S ",i * i)

]

? "Hello World"
quit

for nI := 1 TO 10
 ? nI*nI
next

IDENTIFICATION DIVISION.
PROGRAM-ID. HelloWorld.
AUTHOR. Fabritius.

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
INPUT-OUTPUT SECTION.

DATA DIVISION.
FILE SECTION.
WORKING-STORAGE SECTION.
LINKAGE SECTION.

PROCEDURE DIVISION.
DISPLAY "Hello World".
STOP RUN. 

//
// File:     Ackermann 
// Language: Concurrent Clean 2.0 
// Author:   Michael Neumann (mneumann@ntecs.de)
// Date:     23 March 2002
//

module Ackermann

import StdEnv
import ArgEnv

Ack :: !Int !Int -> !Int
Ack 0 n = n+1
Ack m 0 = Ack (m-1) 1
Ack m n = Ack (m-1) (Ack m (n-1))

Start :: String
Start = "Ack(3," +++ toString n +++ "): " +++ toString (Ack 3 n) +++ "\n"
      where n = toInt (select getCommandLine 1)

//
// File:     Array Access 
// Language: Concurrent Clean 2.0 
// Author:   Michael Neumann (mneumann@ntecs.de)
// Date:     24 March 2002
//

module ArrayAccess

import StdEnv
import ArgEnv

RUNS :== 1000

doIt x y lix =
  loop RUNS y
where
  // loop 'i' times
  loop :: !Int *{#Int} -> *{#Int}
  loop i y
    # y` = add lix y
    | i <= 1    = y`
    | otherwise = loop (i-1) y`
  where
    // adds 'x' to 'y'
    add :: !Int *{#Int} -> *{#Int}
    add i y
      #! e  = y.[i]
      #  y` = {y & [i] = e + x.[i]}
      |  i == 0    = y`
      |  otherwise = add (i-1) y`

Start :: String
Start
  # a = doIt (make_x n) (make_y n) (n-1)
  = toString a.[0] +++ " " +++ toString a.[n-1] +++ "\n"
where
  n = toInt (select getCommandLine 1)

  // creates the 'x' array
  make_x :: !Int -> *{#Int}
  make_x n = fill_x (createArray n 0) (n-1)
  where
    fill_x :: *{#Int} !Int -> *{#Int}
    fill_x x i
      | i == 0     = x`
      | otherwise  = fill_x x` (i-1)
    where
      x` = {x & [i] = i+1}

  // creates the 'y' array
  make_y :: !Int -> *{#Int}
  make_y n = createArray n 0

module Fac

fac :: !Int -> Int
fac 0 = 1
fac 1 = fac 0
fac n = n * fac (dec n)


// Tail recursive (much faster)
fact :: !Int !Int -> Int
fact 0 i = i
fact n i = fact (n-1) (n*i)

//
// File:     Fibonacci 
// Language: Concurrent Clean 2.0
// Author:   Michael Neumann (mneumann@ntecs.de)
// Date:     23 March 2002
//

module Fibonacci

import StdEnv
import ArgEnv

Fib :: !Int -> !Int
Fib n
    | n < 2     = 1
    | otherwise = Fib (n-2) + Fib (n-1)

Start :: String
Start = "Fib(" +++ toString n +++ "): " +++ toString (Fib n) +++ "\n"
      where n = toInt (select getCommandLine 1)

// Hello World

module helloworld
import StdEnv

Start :: String
Start = "Hello World"

module HelloWorld

Start = "Hello World\n"

module squares
import StdEnv

Start :: [(Int, String)]
Start = [(a*a," ") \\ a <- [1..10]]

//
// File:     String Concatenation 
// Language: Concurrent Clean 2.0 
// Author:   Michael Neumann (mneumann@ntecs.de)
// Date:     25 March 2002
//

module StringConcatenation

import StdEnv
import ArgEnv

loop :: !Int *String -> *String
loop 0 s = s
loop i s = loop (i-1) (s +++. "hello\n")

Start = toString (size s) +++ "\n"
where
  s = loop n ""
  n = toInt (select getCommandLine 1)

/* Hello World in Cook */

/* platform-independent using built-in function */
[print "Hello World"];

/* platform-dependent using `echo' */
echo "Hello World";

/** 
 *
 * start from the command-line with:
 *
 *   cook -Book squares.cook
 * 
 * or rename as Howto.cook and invoke:
 * 
 *   cook 
 * 
 * Note that `expr' is a build-in cook command, 
 * and not the UNIX /bin/expr program. 
 * The same applies to `print'.   
 */

loop n = 1 2 3 4 5 6 7 8 9 10
{
  [print [expr [n] * [n]]];
}

{ Hello World in COSY }

BEGIN ;
   WRITE 6 'Hello World' ;   { 6 ist Stdout }
END ;

(* e = Summe der Reziproken der Fakultäten *)



// Fakultäts-Funktion
function fac( int n ) returns int
{
   if( n > 1 ) return n * fac(n-1);
   else return 1;
}


var arr := [ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ];


// filter_arr wendet die übergebene Funktion auf jedes Element des 
// Arrays arr an und schreibt den Rückgabewert zurück ins Array
function filter_arr ( proc(float) returns float transform ) {
   for( var i := 0 ; i < 10; i := i + 1 ) {
      arr[i] := transform(arr[i]);
   }
}


// Fakultäten berechnen
// lambda erzeugt eine namenlose Funktion
// -> ist ein typecast
filter_arr( lambda(float x) returns float { return fac(x -> int) -> float; } );

// Reziproken berechnen
filter_arr( lambda(float x) returns float { return 1.0 / x; } );

// Summe bilden
var float e := 0.0;
filter_arr( lambda(float x) returns float { e := e + x; return x; } );


// e ausgeben
cout << e;

// Fakultäts-Funktion
function fac( int n ) returns int
{
   if( n > 1 ) return n * fac(n-1);
   else return 1;
}

var e := 0.0;

for( var n := 0; n < 10; n := n + 1 ) {
   e := e + 1.0 / fac(n) -> float;
}



// e ausgeben
cout << e;

/* 
 * Berechnen der Fakultät
 */


function fac( int n ) returns int
{
   if( n > 1 ) return n * fac(n-1);
   else return 1;
}


// Funktion aufrufen
cout << fac(6);

// Hello World in C-Talk

cout << "Hello World\n";

(*
 * Squares (* geschachtelter Kommentar *)
 *)


for( var int i:=1; i<=10; i:=i+1 )
{
   cout << i * i << " ";
}

{curl 1.7 applet}
{applet license = "personal"}
Hello World

#include <stdio.h>

int main() {
  printf("Hello World\n");
  return 0;
}

? "Hello World"
return

@ECHO OFF
ECHO Hello World

@ECHO OFF

REM Gibt die Zahlen 0-99 aus
REM Diese Datei muß numbers.bat heißen

IF "%1" == ""       GOTO outer
IF "%1" == "output" GOTO output
IF "%1" == "inner"  GOTO inner
GOTO exit


:inner
FOR %%i IN (0 1 2 3 4 5 6 7 8 9) DO CALL numbers output %2 %%i
GOTO exit


:outer
FOR %%i IN (0 1 2 3 4 5 6 7 8 9) DO CALL numbers inner %%i
GOTO exit


:output
IF "%2" == "0" ECHO %3
IF NOT "%2" == "0" ECHO %2%3


:exit