zettacode 0.1.3 → 0.1.4

data/files.zettacode2/arithmetic.integer/tcl.txt

@@ -0,0 +1,19 @@
+puts "Please enter two numbers:"
+
+set x [expr {int([gets stdin])}]; # Force integer interpretation
+set y [expr {int([gets stdin])}]; # Force integer interpretation
+
+puts "$x + $y = [expr {$x + $y}]"
+puts "$x - $y = [expr {$x - $y}]"
+puts "$x * $y = [expr {$x * $y}]"
+puts "$x / $y = [expr {$x / $y}]"
+puts "$x mod $y = [expr {$x % $y}]"
+puts "$x 'to the' $y = [expr {$x ** $y}]"
+
+Since Tcl doesn't really know about the "type" of a variable, the "<tt>expr</tt>" command is used to declare whatever follows as an "expression". This means there is no such thing as "integer arithmetic" and hence the kludge with <tt>int([gets&amp;nbsp;stdin])</tt>.
+
+Often, these operations would be performed in a different way from what is shown here. For example, to increase the variable "x" by the value of the variable "y", one would write
+
+incr x $y
+
+Also, it's important to surround the arguments to the <code>expr</code> in braces, especially when any of the parts of the expression are not literal constants.  Discussion of this is on [http://wiki.tcl.tk/10225 The Tcler's Wiki].

data/files.zettacode2/arithmetic.integer/terraform.txt

@@ -0,0 +1,33 @@
+HCL doesn't have an exponentiation operator and even integer division is contrived as shown in the code, but at least it prints the output variables alphabetically without any effort.......
+
+#Aamrun, 15th August 2022
+
+variable "a" {
+  type = number
+}
+
+variable "b" {
+  type = number
+}
+
+output "Sum" {
+  value = var.a + var.b
+}
+
+output "Difference" {
+  value = var.a - var.b
+}
+
+output "Product" {
+  value = var.a * var.b
+}
+
+output "Quotient" {
+  value = floor(var.a / var.b)
+}
+
+output "Remainder" {
+  value = var.a % var.b
+}
+
+The floor function rounds to the closest lowest integer. Invocation and output are as below :

data/files.zettacode2/arithmetic.integer/ti-83_basic.txt

@@ -0,0 +1,14 @@
+Pauses added due to TI-83's lack of screen size.
+
+Prompt A,B
+Disp "SUM"
+Pause A+B
+Disp "DIFFERENCE"
+Pause A-B
+Disp "PRODUCT"
+Pause AB
+Disp "INTEGER QUOTIENT"
+Pause int(A/B)
+Disp "REMAINDER"
+Pause A-B*int(A/B)
+

data/files.zettacode2/arithmetic.integer/ti-89_basic.txt

@@ -0,0 +1,8 @@
+
+Local a, b
+Prompt a, b
+Disp "Sum: " & string(a + b)
+Disp "Difference: " & string(a - b)
+Disp "Product: " & string(a * b)
+Disp "Integer quotient: " & string(intDiv(a, b))
+Disp "Remainder: " & string(remain(a, b))

data/files.zettacode2/arithmetic.integer/toka.txt

@@ -0,0 +1,7 @@
+
+[ ( a b -- )
+  2dup ." a+b = " + . cr  
+  2dup ." a-b = " - . cr  
+  2dup ." a*b = " * . cr  
+  2dup ." a/b = " / . ." remainder " mod . cr  
+] is mathops

data/files.zettacode2/arithmetic.integer/tuscript.txt

@@ -0,0 +1,9 @@
+
+$$ MODE TUSCRIPT
+a=5
+b=3
+c=a+b
+c=a-b
+c=a*b
+c=a/b
+c=a%b

data/files.zettacode2/arithmetic.integer/unix_shell.txt

@@ -0,0 +1,29 @@
+
+The Unix shell does not directly support arithmetic operations, so external tools, such as ''expr'' are used to perform arithmetic calculations when required:
+
+{{works with|Bourne Shell}}
+{{works with|Almquist SHell}}
+#!/bin/sh
+read a; read b;
+echo "a+b     = "  `expr $a  +  $b`
+echo "a-b     = "  `expr $a  -  $b`
+echo "a*b     = "  `expr $a \*  $b`
+echo "a/b     = "  `expr $a  /  $b` # truncates towards 0
+echo "a mod b = "  `expr $a  %  $b` # same sign as first operand
+
+Notes: Using the ` (backtick operators, also available in most Bourne shells via the ''$(...)'' syntax) allows us to keep the results on their labels in the most efficient and portable way. The spaces around the operators in the ''expr'' command line arguments are required and the shell requires us to quote or escape the ''*'' character has shown, to prevent any possible "globbing" --- filename expansion of the ''*'' as a wildcard character.
+
+With SUSv3 parameter expansions:
+
+{{works with|Bourne Again SHell|3.2}}
+{{works with|pdksh|5.2.14}}
+{{works with|Z SHell}}
+#!/bin/sh
+read a; read b;
+echo "a+b     = $((a+b))"
+echo "a-b     = $((a-b))"
+echo "a*b     = $((a*b))"
+echo "a/b     = $((a/b))" # truncates towards 0
+echo "a mod b = $((a%b))" # same sign as first operand
+
+Note: spaces inside the ''$((...))'' are optional and not required; the ''$((...))'' can be inside or outside the double quotes, but the `...` expressions from the previous example can also be inside or outside the double quotes.

data/files.zettacode2/arithmetic.integer/ursa.txt

@@ -0,0 +1,27 @@
+#
+# integer arithmetic
+#
+
+decl int x y
+out "number 1: " console
+set x (in int console)
+out "number 2: " console
+set y (in int console)
+
+out "\nsum:\t" (int (+ x y)) endl console
+out "diff:\t" (int (- x y)) endl console
+out "prod:\t" (int (* x y)) endl console
+# quotient doesn't round at all, but the int function rounds up
+out "quot:\t" (int (/ x y)) endl console
+# mod takes the sign of x
+out "mod:\t" (int (mod x y)) endl console
+
+Sample session:
+number 1: 15
+number 2: 7
+
+sum:	22
+diff:	8
+prod:	105
+quot:	2
+mod:	1

data/files.zettacode2/arithmetic.integer/v_(vlang).txt

@@ -0,0 +1,29 @@
+// Arithmetic-integer in V (Vlang)
+// Tectonics: v run arithmetic-integer.v
+module main
+import math
+import os
+
+// starts here
+pub fn main() {
+    mut a := 0
+    mut b := 0
+
+    // get numbers from console
+    print("Enter two integer numbers, separated by a space: ")
+    text := os.get_raw_line()
+    values := text.split(' ')
+    a = values[0].int()
+    b = values[1].int()
+
+    // 4 basics, remainder, no exponentiation operator
+    println("values:           a $a, b $b")
+    println("sum:              a + b = ${a + b}")
+    println("difference:       a - b = ${a - b}")
+    println("product:          a * b = ${a * b}")
+    println("integer quotient: a / b = ${a / b}, truncation")
+    println("remainder:        a % b = ${a % b}, sign follows dividend")
+
+    println("no exponentiation operator")
+    println("  math.pow:    pow(a,b) = ${math.pow(a,b)}")
+}

data/files.zettacode2/arithmetic.integer/vba.txt

@@ -0,0 +1,19 @@
+
+'Arithmetic - Integer
+Sub RosettaArithmeticInt()
+Dim opr As Variant, a As Integer, b As Integer
+On Error Resume Next
+
+a = CInt(InputBox("Enter first integer", "XLSM | Arithmetic"))
+b = CInt(InputBox("Enter second integer", "XLSM | Arithmetic"))
+
+Debug.Print "a ="; a, "b="; b, vbCr
+For Each opr In Split("+ - * / \ mod ^", " ")
+    Select Case opr
+        Case "mod":     Debug.Print "a mod b", a; "mod"; b, a Mod b
+        Case "\":       Debug.Print "a \ b", a; "\"; b, a \ b
+        Case Else:      Debug.Print "a "; opr; " b", a; opr; b, Evaluate(a & opr & b)
+    End Select
+Next opr
+End Sub
+

data/files.zettacode2/arithmetic.integer/vbscript.txt

@@ -0,0 +1,51 @@
+VBScript's variables are all Variants. What starts out as an integer may be converted to something else if the need arises.
+
+===Implementation===
+option explicit
+dim a, b
+wscript.stdout.write "A? "
+a = wscript.stdin.readline
+wscript.stdout.write "B? "
+b = wscript.stdin.readline
+
+a = int( a )
+b = int( b )
+
+wscript.echo "a + b=", a + b
+wscript.echo "a - b=", a - b
+wscript.echo "a * b=", a * b
+wscript.echo "a / b=", a / b
+wscript.echo "a \ b=", a \ b
+wscript.echo "a mod b=", a mod b
+wscript.echo "a ^ b=", a ^ b
+
+===Another Implementation===
+Gives the same output for the same input. Inspired by Python version.
+option explicit
+dim a, b
+wscript.stdout.write "A? "
+a = wscript.stdin.readline
+wscript.stdout.write "B? "
+b = wscript.stdin.readline
+
+a = int( a )
+b = int( b )
+
+dim op
+for each op in split("+ - * / \ mod ^", " ")
+	wscript.echo "a",op,"b=",eval( "a " & op & " b")
+next
+
+===Invocation===
+
+C:\foo>arithmetic.vbs
+A? 45
+B? 11
+a + b= 4511
+a - b= 34
+a * b= 495
+a / b= 4.09090909090909
+a \ b= 4
+a mod b= 1
+a ^ b= 1.5322783012207E+18
+

data/files.zettacode2/arithmetic.integer/vedit_macro_language.txt

@@ -0,0 +1,8 @@
+#1 = Get_Num("Give number a: ")
+#2 = Get_Num("Give number b: ")
+Message("a + b = ") Num_Type(#1 + #2)
+Message("a - b = ") Num_Type(#1 - #2)
+Message("a * b = ") Num_Type(#1 * #2)
+Message("a / b = ") Num_Type(#1 / #2)
+Message("a % b = ") Num_Type(#1 % #2)
+

data/files.zettacode2/arithmetic.integer/verilog.txt

@@ -0,0 +1,26 @@
+module main;
+  integer a, b;
+  integer suma, resta, producto;
+  integer division, resto, expo;
+  
+  initial begin
+    a = -12;
+    b = 7;
+    
+    suma = a + b;
+    resta = a - b;
+    producto = a * b;
+    division = a / b;
+    resto = a % b;
+    expo = a ** b;
+    
+    $display("Siendo dos enteros a = -12 y b = 7");
+    $display("       suma de a + b = ", suma);
+    $display("      resta de a - b = ", resta);
+    $display("   producto de a * b = ", producto);
+    $display("   división de a / b = ", division);
+    $display("   resto de a mod  b = ", resto);
+    $display("exponenciación a ^ b = ", expo);
+    $finish ;
+  end
+endmodule

data/files.zettacode2/arithmetic.integer/vim_script.txt

@@ -0,0 +1,10 @@
+let a = float2nr(input("Number 1: ") + 0)
+let b = float2nr(input("Number 2: ") + 0)
+echo "\nSum: " . (a + b)
+echo "Difference: " . (a - b)
+echo "Product: " . (a * b)
+" The result of an integer division is truncated
+echo "Quotient: " . (a / b)
+" The sign of the result of the remainder operation matches the sign of 
+" the first operand 
+echo "Remainder: " . (a % b)

data/files.zettacode2/arithmetic.integer/visual_basic_.net.txt

@@ -0,0 +1,14 @@
+Imports System.Console
+Module Module1
+  Sub Main
+    Dim a = CInt(ReadLine)
+    Dim b = CInt(ReadLine)
+    WriteLine("Sum " & a + b)
+    WriteLine("Difference " & a - b)
+    WriteLine("Product " & a - b)
+    WriteLine("Quotient " & a / b)
+    WriteLine("Integer Quotient " & a \ b)
+    WriteLine("Remainder " & a Mod b)
+    WriteLine("Exponent " & a ^ b)
+  End Sub
+End Module

data/files.zettacode2/arithmetic.integer/wart.txt

@@ -0,0 +1,9 @@
+a <- (read)
+b <- (read)
+prn "sum: " a+b
+prn "difference: " a-b
+prn "product: " a*b
+prn "quotient: " a/b
+prn "integer quotient: " (int a/b)
+prn "remainder: " a%b
+prn "exponent: " a^b

data/files.zettacode2/arithmetic.integer/wren.txt

@@ -0,0 +1,16 @@
+In Wren the quotient operator '/' does not round but, when the ''floor'' method is applied to the result, it rounds to the lower integer.
+
+The sign of the remainder operator '%' matches the sign of the first operand.
+import "io" for Stdin, Stdout
+System.write("first number:     ")
+Stdout.flush()
+var a = Num.fromString(Stdin.readLine())
+System.write("second number:    ")
+Stdout.flush()
+var b = Num.fromString(Stdin.readLine())
+System.print("sum:              %(a + b)")
+System.print("difference:       %(a - b)")
+System.print("product:          %(a * b)")
+System.print("integer quotient: %((a / b).floor)")
+System.print("remainder:        %(a % b)")
+System.print("exponentiation:   %(a.pow(b))")

data/files.zettacode2/arithmetic.integer/x86_assembly.txt

@@ -0,0 +1,23 @@
+Input and output would be OS-specific and are not implemented. This routine works on the 16-bit 8086, as well as on its 32-bit and 64-bit successors: it could be trivially modified to perform 32-bit or 64-bit arithmetic on machines where those are supported. The quotient is truncated towards zero; the remainder takes its sign from the first operand.
+arithm: mov      cx,          a
+        mov      bx,          b
+        xor      dx,          dx
+        
+        mov      ax,          cx
+        add      ax,          bx
+        mov      sum,         ax
+        
+        mov      ax,          cx
+        imul     bx
+        mov      product,     ax
+        
+        mov      ax,          cx
+        sub      ax,          bx
+        mov      difference,  ax
+        
+        mov      ax,          cx
+        idiv     bx
+        mov      quotient,    ax
+        mov      remainder,   dx
+
+        ret

data/files.zettacode2/arithmetic.integer/xlisp.txt

@@ -0,0 +1,17 @@
+(DEFUN INTEGER-ARITHMETIC ()
+    (DISPLAY "Enter two integers separated by a space.")
+    (NEWLINE)
+    (DISPLAY "> ")
+    (DEFINE A (READ))
+    (DEFINE B (READ))
+    (DISPLAY `(SUM ,(+ A B)))
+    (NEWLINE)
+    (DISPLAY `(DIFFERENCE ,(- A B)))
+    (NEWLINE)
+    (DISPLAY `(PRODUCT ,(* A B)))
+    (NEWLINE)
+    (DISPLAY `(QUOTIENT ,(QUOTIENT A B))) ; truncates towards zero
+    (NEWLINE)
+    (DISPLAY `(REMAINDER ,(REM A B))) ; takes sign of first operand
+    (NEWLINE)
+    (DISPLAY `(EXPONENTIATION ,(EXPT A B))))

data/files.zettacode2/arithmetic.integer/xpl0.txt

@@ -0,0 +1,10 @@
+include c:\cxpl\codes;
+int A, B;
+[A:= IntIn(0);
+ B:= IntIn(0);
+IntOut(0, A+B); CrLf(0);
+IntOut(0, A-B); CrLf(0);
+IntOut(0, A*B); CrLf(0);
+IntOut(0, A/B); CrLf(0);        \truncates toward zero
+IntOut(0, rem(0)); CrLf(0);     \remainder's sign matches first operand (A)
+]

data/files.zettacode2/arithmetic.integer/xslt.txt

@@ -0,0 +1,10 @@
+<xsl:template name="arithmetic">
+  <xsl:param name="a">5</xsl:param>
+  <xsl:param name="b">2</xsl:param>
+  <fo:block>a + b = <xsl:value-of select="$a + $b"/></fo:block>
+  <fo:block>a - b = <xsl:value-of select="$a - $b"/></fo:block>
+  <fo:block>a * b = <xsl:value-of select="$a * $b"/></fo:block>
+  <fo:block>a / b = <xsl:value-of select="round($a div $b)"/></fo:block>
+  <fo:block>a mod b = <xsl:value-of select="$a mod $b"/></fo:block>
+ </xsl:template>
+

data/files.zettacode2/arithmetic.integer/yabasic.txt

@@ -0,0 +1,11 @@
+input "ingrese un numero? " a
+input "ingrese otro numero? " b
+
+print "suma      ", a, " + ", b, " = ", (a + b)
+print "resta     ", a, " - ", b, " = ", (a - b)
+print "producto  ", a, " * ", b, " = ", (a * b)
+print "division  ", a, " \ ", b, " = ", int(a / b)
+print "modulo    ", a, " % ", b, " = ", mod(a, b)
+print "potencia  ", a, " ^ ", b, " = ", (a ^ b)
+end
+

data/files.zettacode2/arithmetic.integer/yorick.txt

@@ -0,0 +1,8 @@
+x = y = 0;
+read, x, y;
+write, "x + y =", x + y;
+write, "x - y =", x - y;
+write, "x * y =", x * y;
+write, "x / y =", x / y; // rounds toward zero
+write, "x % y =", x % y; // remainder; matches sign of first operand when operands' signs differ
+write, "x ^ y =", x ^ y; // exponentiation

data/files.zettacode2/arithmetic.integer/zkl.txt

@@ -0,0 +1,7 @@
+x,y:=ask("Two ints: ").split(" ").apply("toInt");
+println("x+y = ",x + y);
+println("x-y = ",x - y);
+println("x*y = ",x * y);
+println("x/y = ",x / y); // rounds toward zero
+println("x%y = ",x % y); // remainder; matches sign of first operand when operands' signs differ
+println("x.divr(y) = ",x.divr(y)); // (x/y,remainder); sign as above

data/files.zettacode2/arithmetic.integer/zonnon.txt

@@ -0,0 +1,13 @@
+
+module Main;
+var
+	i,j: integer;
+begin
+	write("A integer?:");readln(i);
+	write("another?: ");readln(j);
+	writeln("sum: ",i + j);
+	writeln("difference: ", i - j);
+	writeln("product: ", i * j);
+	writeln("quotient: ", i div j);
+	writeln("remainder: ", i mod j);
+end Main.

data/files.zettacode2/arithmetic.integer/zx_spectrum_basic.txt

@@ -0,0 +1,11 @@
+5 LET a=5: LET b=3
+10 PRINT a;" + ";b;" = ";a+b
+20 PRINT a;" - ";b;" = ";a-b
+30 PRINT a;" * ";b;" = ";a*b
+40 PRINT a;" / ";b;" = ";INT (a/b)
+50 PRINT a;" mod ";b;" = ";a-INT (a/b)*b
+60 PRINT a;" to the power of ";b;" = ";a^b
+
+      <sha1>jmu2t0w01l2tasbm4sraa95rv96cj5t</sha1>
+    
+  

data/files.zettacode2/arithmetic.integer//320/274/320/272-61-52.txt

@@ -0,0 +1,7 @@
+П1	<->	П0
++	С/П
+ИП0	ИП1	-	С/П
+ИП0	ИП1	*	С/П
+ИП0	ИП1	/	[x]	С/П
+ИП0	^	ИП1	/	[x]	ИП1	*	-	С/П
+ИП1	ИП0	x^y	С/П

data/files.zettacode2/hello_world.text/0815.txt

@@ -0,0 +1,7 @@
+
+<:48:x<:65:=<:6C:$=$=$$~<:03:+
+$~<:ffffffffffffffb1:+$<:77:~$
+~<:fffffffffffff8:x+$~<:03:+$~
+<:06:x-$x<:0e:x-$=x<:43:x-$
+
+

data/files.zettacode2/hello_world.text/11l.txt

@@ -0,0 +1 @@
+print(‘Hello world!’)

data/files.zettacode2/hello_world.text/360_assembly.txt

@@ -0,0 +1,17 @@
+Using native SVC (Supervisor Call) to write to system console:
+<syntaxhighlight lang="360 assembly">
+HELLO    CSECT 
+         USING HELLO,15
+         LA    1,MSGAREA     Point Register 1 to message area
+         SVC   35            Invoke SVC 35 (Write to Operator) 
+         BR    14            Return
+MSGAREA  EQU   *             Message Area
+         DC    AL2(19)       Total area length = 19 (Prefix length:4 + Data Length:15) 
+         DC    XL2'00'       2 bytes binary of zeros
+         DC    C'Hello world!'  Text to be written to system console
+         END
+Using WTO Macro to generate SVC 35 and message area:
+<syntaxhighlight lang="360 assembly">         WTO   'Hello world!'
+         BR    14            Return
+         END
+

data/files.zettacode2/hello_world.text/4dos_batch.txt

@@ -0,0 +1 @@
+echo Hello world!

data/files.zettacode2/hello_world.text/6502_assembly.txt

@@ -0,0 +1,22 @@
+; goodbyeworld.s for C= 8-bit machines, ca65 assembler format.
+; String printing limited to strings of 256 characters or less.
+
+a_cr	= $0d		; Carriage return.
+bsout	= $ffd2		; C64 KERNEL ROM, output a character to current device.
+			; use $fded for Apple 2, $ffe3 (ascii) or $ffee (raw) for BBC.
+	.code
+
+	ldx #0		; Starting index 0 in X register.
+printnext:
+	lda text,x	; Get character from string.
+	beq done	; If we read a 0 we're done.
+	jsr bsout	; Output character. 
+	inx		; Increment index to next character.
+	bne printnext	; Repeat if index doesn't overflow to 0.
+done:
+	rts		; Return from subroutine.
+
+	.rodata
+
+text:
+	.byte	"Hello world!", a_cr, 0

data/files.zettacode2/hello_world.text/6800_assembly.txt

@@ -0,0 +1,31 @@
+        .cr  6800
+        .tf  gbye6800.obj,AP1
+        .lf  gbye6800
+;=====================================================;
+;        Hello world! for the Motorola 6800        ;
+;                 by barrym 2013-03-17                ;
+;-----------------------------------------------------;
+; Prints the message "Hello world!" to an ascii    ;
+;   terminal (console) connected to a 1970s vintage   ;
+;   SWTPC 6800 system, which is the target device for ;
+;   this assembly.                                    ;
+; Many thanks to:                                     ;
+;   swtpc.com for hosting Michael Holley's documents! ;
+;   sbprojects.com for a very nice assembler!         ;
+;   swtpcemu.com for a very capable emulator!         ;
+; reg x is the string pointer                         ;
+; reg a holds the ascii char to be output             ;
+;-----------------------------------------------------;
+outeee   =   $e1d1      ;ROM: console putchar routine
+        .or  $0f00
+;-----------------------------------------------------;
+main    ldx  #string    ;Point to the string
+        bra  puts       ;  and print it
+outs    jsr  outeee     ;Emit a as ascii
+        inx             ;Advance the string pointer
+puts    ldaa ,x         ;Load a string character
+        bne  outs       ;Print it if non-null
+        swi             ;  else return to the monitor
+;=====================================================;
+string  .as  "Hello world!",#13,#10,#0
+        .en

data/files.zettacode2/hello_world.text/8080_assembly.txt

@@ -0,0 +1,12 @@
+
+	; This is Hello World, written in 8080 assembly to run under CP/M
+	; As you can see, it is similar to the 8086, and CP/M is very
+	; similar to DOS in the way it is called.
+	org	100h	; CP/M .COM entry point is 100h - like DOS
+	mvi	c,9	; C holds the syscall, 9 = print string - like DOS
+	lxi	d,msg	; DE holds a pointer to the string
+	jmp	5	; CP/M calls are accessed through the jump at 05h
+	; Normally you'd CALL it, but since you'd end the program by RETurning,
+	; JMP saves a byte (if you've only got 64k of address space you want to
+	; save bytes). 
+msg:	db	'Hello world!$'

data/files.zettacode2/hello_world.text/8086_assembly.txt

@@ -0,0 +1,30 @@
+
+DOSSEG
+.MODEL TINY
+.DATA
+TXT DB "Hello world!$"
+.CODE
+START:
+	MOV ax, @DATA
+	MOV ds, ax
+	
+	MOV ah, 09h		; prepare output function
+	MOV dx, OFFSET TXT	; set offset
+	INT 21h			; output string TXT
+	
+	MOV AX, 4C00h 		; go back to DOS
+	INT 21h
+END START
+
+With A86 or NASM syntax:
+  org 100h
+
+  mov dx, msg
+  mov ah, 9
+  int 21h
+
+  mov ax, 4c00h
+  int 21h
+
+msg:
+  db "Hello world!$"

data/files.zettacode2/hello_world.text/8th.txt

@@ -0,0 +1 @@
+"Hello world!\n" . bye

data/files.zettacode2/hello_world.text/aarch64_assembly.txt

@@ -0,0 +1,22 @@
+.equ STDOUT, 1
+.equ SVC_WRITE, 64
+.equ SVC_EXIT, 93
+
+.text
+.global _start
+
+_start:
+	stp x29, x30, [sp, -16]!
+	mov x0, #STDOUT
+	ldr x1, =msg
+	mov x2, 13
+	mov x8, #SVC_WRITE
+	mov x29, sp
+	svc #0 // write(stdout, msg, 13);
+	ldp x29, x30, [sp], 16
+	mov x0, #0
+	mov x8, #SVC_EXIT
+	svc #0 // exit(0);
+
+msg:	.ascii "Hello World!\n"
+.align 4

data/files.zettacode2/hello_world.text/abap.txt

@@ -0,0 +1,2 @@
+REPORT zgoodbyeworld.
+  WRITE 'Hello world!'.

data/files.zettacode2/hello_world.text/acl2.txt

@@ -0,0 +1,2 @@
+(cw "Hello world!~%")
+