Mais um blog inútil.

#!/opt/local/bin/python
# this script can never fail
import os
import struct

dat = open("EDEN.DAT", "rb")

dat.seek(0)
(total,) = struct.unpack("<H", dat.read(2))
print "O total de ficheiros e: %i" % total

# primeiro 0x2 - 2
# segundo 0x1b - 27
# terceiro 0x34 - 52

for info in range(0,total):
#for info in range(0,1000):
    start = 2+25*info
    
    dat.seek(start)
    filename = str.strip(dat.read(12),'\x00')
    if filename != "":
        print "Filename: %s" % filename
    
        dat.seek(start+16)
        (file_size,) = struct.unpack("<L", dat.read(4))
        print "Tamanho : %i bytes" % file_size
    
        dat.seek(start+20)
        (file_offset,) = struct.unpack("<L", dat.read(4))
        print "Offset: 0x%x" % file_offset
    
        destfn = os.path.join("rip/",filename)
        print "A escrever ficheiro %i: %s " % (info, repr(destfn))
        dat.seek(file_offset)
        dest = open(destfn, "wb")
        dest.write(dat.read(file_size))
        dest.close

dat.close

hpux$ cat arvorezinha.S
        .LEVEL 1.1							; cenas gays do hpux
        .SPACE $PRIVATE$						; o HPPA funciona por spaces, ler arch book
        .SUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31				; pra mais informacoes ou esquizofrenia antecipada
        .SUBSPA $BSS$,QUAD=1,ALIGN=8,ACCESS=31,ZERO,SORT=82
        .SPACE $TEXT$
        .SUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=44
        .SUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
        .IMPORT $global$,DATA
        .IMPORT $$dyncall,MILLICODE
        .IMPORT write,CODE						; eh mais simpatico fazer imports
        .IMPORT exit,CODE
        .IMPORT __main,CODE
        .SPACE $TEXT$
        .SUBSPA $LIT$

        .align 4
STAR
        .STRING "\x2a\x00"
LF
        .STRING "\x0a\x00"
        .SPACE $TEXT$
        .SUBSPA $CODE$

        .align 4
        .NSUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
        .EXPORT main,ENTRY,PRIV_LEV=3,RTNVAL=GR				; a cena dos privilege levels eh funny
main
        .PROC
        .CALLINFO FRAME=64,CALLS,SAVE_RP,SAVE_SP,ENTRY_GR=3
        .ENTRY
        .CALL
        xor     %r4,%r4,%r4						; aka meter %r4 a zero :)

arewedoneyet
        comib,=,n 5,%r4,kk10xbai					; se %r4 for 5, BAI NAO!
        nop
        xor     %r3,%r3,%r3						; inicializar o counter do segundo loope

letsdothis
        comb,<=,n %r3,%r4,estrela					; se o %r3 for menor ou igual a %r4
        xor %r1,%r1,%r26						; sim, isto eh um nop							

        ldi 1,%r26							; escolher o fd (1 eh stdout)
        ldil LR'LF,%r19							; copiar a stringue com
        ldo RR'LF(%r19),%r25						; paneleirices...
        ldi 1,%r24							; length da stringue
        .CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
        bl write,%r2
        xor %r1,%r2,%r3							; sim, isto eh um nop

        addi    1,%r4,%r4						; incrementar o %r4
        b       arewedoneyet
        shladd %r4,2,%r8,%r15						; sim, isto eh um nop

estrela
        ldi 1,%r26							; ver outro write
        ldil LR'STAR,%r19						; eh a mm merda
        ldo RR'STAR(%r19),%r25
        ldi 1,%r24
        .CALL ARGW0=GR,ARGW1=GR,ARGW2=GR
        bl write,%r2
        add %r13,%r14,%r15						; sim, isto eh um nop

        addi    1,%r3,%r3
        b       letsdothis
        nop								; adivinha...

kk10xbai
        ldi 0,%r26
        .CALL ARGW0=GR
        bl exit,%r2
        shrpw %r8,%r7,8,%r9     ; nop nop nop
        subi,OD  42,%r3,%r12    ; nop nop nop nopppppp! :D
        .EXIT
        .PROCEND
hpux$ gcc arvorezinha.S
*
**
***
****
*****
hpux$

solaris$ cat arvore.S
.section  ".rodata1"
.align    4
.L0:
        .ascii           "*\0"
.L1:
        .ascii          "\n\0"

.L2:
        .ascii          "bla\n\0"

        .section        ".text"
        .global         main
main:
        save            %sp,-96,%sp
        mov 0,%g2

arewedoneyet:
        cmp %g2,5       ! comparar com RFC_MAX pois claro, n eh preciso registry pra isto
        be weredonefaggot

        mov 0,%g3       ! inicializar counter1

estrelitas:
        cmp %g3,%g2     ! ah e tal, compara-me a pissa, less or equal?
        ble estrela

        set .L1,%o0     ! meter LF no output register, e mandar printar
        call printf

        inc %g2         ! increasar o counter2
        ba arewedoneyet

estrela:
        set     .L0,%o0 ! printar estrelinha
        call    printf

        inc %g3
        ba estrelitas

weredonefaggot:
        nop
        restore

solaris$ gcc arvore.S -o arvorezinha
solaris$ ./arvorezinha
*
**
***
****
*****
solaris$

true64> gcc arvore.S -o arvorezinha
true64> ./arvorezinha
*
**
***
****
*****
true64> cat arvore.S
.data
LF:             .ascii          "\n\0"
GAY:            .ascii          "*"

.text
        .align  4
        .set    noreorder
        .arch   ev4
        .globl  main
        .ent    main

main:
        ldgp    $gp,0($27)		# load ao global pointer
        stq     $26,0($sp)			# inicializar o stack pointer (só naquela)

        lda $10,5                       	# RFC_MAX para o loop principal
        lda $9,0				# counter do loop1

loop1:
        cmpeq $9,$10,$7			# se $9 igual $10, branchar para o final
        bne $7,final

        lda $11,0				# counter para o loop2

loop2:
        cmple $11,$9,$7			# se $11 menor ou igual q $9, estrelar!
        bne $7,estrela

        lda $16,LF				# new line pl0x
        jsr $26,printf
        ldgp $gp,0($26)

        lda $9,1($9)			# uma maneira gay de incrementar
        br loop1

estrela:
        lda     $16,GAY			# printar estrelinha...
        jsr     $26,printf			# é sempre preciso fazer reset ao $gp
        ldgp    $gp,0($26)		# depois de usar uma função

        addq $11,1,$11			# outra maneira gay de incrementar :p
        br loop2

final:
        mov     $31,$0                  # return = 0
        ldq     $26,0($sp)              # limpar a stacka, se bem q nao foi usado mas pronto..
        ret     $31,($26),1             # returnarrrrrrrrr
        .end    main

true64>

#include <iostream>

enum
{
	LIMIT = 5+1
};

template <int x>
void inner(void)
{
	std::cout << '*';
	inner<x-1>();
}

template <>
void inner<0>(void){}

template <int x>
void outer(void)
{
	inner<x>();
	std::cout << std::endl;
	outer<x+1>();
}

template<>
void outer<LIMIT>(void){}

int main(int argc, char **argv)
{
	outer<1>();
	return 0;
}

/* this script can never fail */
MAX = 5
do i = 1 to MAX by 1
	linha = ""
	do x = 1 to i by 1
		linha = linha || "*"
	end
	say linha
end

/* this crap can never fail */

package main

import "os"

func main() {
	var RFC_MAX int = 5
	for i := 1; i <= RFC_MAX; i++ {
		for x := 0; x < i; x++ {
			os.Stdout.WriteString("*")
		}
		os.Stdout.WriteString("\n")
	}
}

seg001:0054                         loc_18FE4:                              ; CODE XREF: _main+47j
seg001:0054 9A 25 00 E4 61                          call    sub_61E65       ; Função do check
seg001:0059
seg001:0059                         loc_18FE9:                              ; CODE XREF: _main+99j
seg001:0059 1E                                      push    ds
seg001:005A 68 18 01                                push    offset aChampionshipMa ; "Championship Manager Italia"
seg001:005D 9A F9 48 83 1A                          call    sub_1F129       ; Call Procedure
seg001:0062 1E                                      push    ds
seg001:0063 68 35 01                                push    offset aHelpNewGameCon ; "*Help|New Game|Continue Season|Quick St"...

* -------------------------------------------can never fail-
* Program    : arvorezinha
* Written by : Pedro de Oliveira
* Date       : 16/05/2010
* Description: Implementação da arvorezinha em 68K assembly 
*-----------------------------------------------------------
        ORG     $1000
START:                          ; first instruction of program

main:
        MOVE.B  #5,d7           ; maximo de linhas/asteriscos
                                ; está a usar o RFC standard 5
        MOVE.B  #0,d5           ; inicializa o counter1 (d5) a 0

ciclo1:
        CMP.B   d5,d7           ; verifica se chegamos o fim
                                ; comparando o counter1 ao maximo
        BEQ     final           ; se for igual salta para o fim
	
        MOVE.B  #0,d6           ; inicializa o counter2 (d6) a 0

ciclo2:
        CMP.B   d5,d6           ; compara o counter1 com o counter2
        BEQ     estrela         ; se for igual
        BLT     estrela         ; ou menor imprime um asterisco
	
        LEA     newline,a1      ; imprime uma newline
        JSR     print
	
        ADD     #1,d5           ; incrementa o counter1
        JMP     ciclo1          ; salta para o ciclo1

estrela:
        LEA     _estrel,a1      ; imprime um asterisco
        JSR     print
	
        ADD     #1,d6           ; incrementa o counter2
        JMP     ciclo2          ; salta para o ciclo2

final:
        MOVE.B  #9,D0
        TRAP    #15             ; halt simulator

print:
        MOVE.B  #14,d0
        TRAP    #15
        RTS

* Variables and Strings

_estrel	DC.B    '*',0
newline DC.B    $0D,$0A,0

        END     START           ; last line of source