include "\SrcALL\68000_Macros.asm"
;Ram Variables
Cursor_X equ $00FF0000		;Ram for Cursor Xpos
Cursor_Y equ $00FF0000+1	;Ram for Cursor Ypos

conwayTilemapRam equ $00FF1000
conwayBackupTilemapRam equ $00FF2000
;Video Ports
VDP_data	EQU	$C00000	; VDP data, R/W word or longword access only
VDP_ctrl	EQU	$C00004	; VDP control, word or longword writes only

;constants
ROWLENGTH equ 40

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 					Traps
	DC.L	$FFFFFE00		;SP register value
	DC.L	ProgramStart	;Start of Program Code
	DS.L	7,IntReturn		; bus err,addr err,illegal inst,divzero,CHK,TRAPV,priv viol
	DC.L	IntReturn		; TRACE
	DC.L	IntReturn		; Line A (1010) emulator
	DC.L	IntReturn		; Line F (1111) emulator
	DS.L	4,IntReturn		; Reserverd /Coprocessor/Format err/ Uninit Interrupt
	DS.L	8,IntReturn		; Reserved
	DC.L	IntReturn		; spurious interrupt
	DC.L	IntReturn		; IRQ level 1
	DC.L	IntReturn		; IRQ level 2 EXT
	DC.L	IntReturn		; IRQ level 3
	DC.L	IntReturn		; IRQ level 4 Hsync
	DC.L	IntReturn		; IRQ level 5
	DC.L	IntReturn		; IRQ level 6 Vsync
	DC.L	IntReturn		; IRQ level 7
	DS.L	16,IntReturn	; TRAPs
	DS.L	16,IntReturn	; Misc (FP/MMU)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;					Header
	DC.B	"SEGA GENESIS    "	;System Name
	DC.B	"(C)CHBI "			;Copyright
 	DC.B	"2019.JAN"			;Date
	DC.B	"ChibiAkumas.com                                 " ; Cart Name
	DC.B	"ChibiAkumas.com                                 " ; Cart Name (Alt)
	DC.B	"GM CHIBI001-00"	;TT NNNNNNNN-RR T=Type (GM=Game) N=game Num  R=Revision
	DC.W	$0000				;16-bit Checksum (Address $000200+)
	DC.B	"J               "	;Control Data (J=3button K=Keyboard 6=6button C=cdrom)
	DC.L	$00000000			;ROM Start
	DC.L	$003FFFFF			;ROM Length
	DC.L	$00FF0000,$00FFFFFF	;RAM start/end (fixed)
	DC.B	"            "		;External RAM Data
	DC.B	"            "		;Modem Data
	DC.B	"                                        " ;MEMO
	DC.B	"JUE             "	;Regions Allowed

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;					Generic Interrupt Handler
IntReturn:
	rte
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;					Program Start
ProgramStart:
	;initialize TMSS (TradeMark Security System)
	move.b ($A10001),D0		;A10001 test the hardware version
	and.b #$0F,D0
	beq	NoTmss				;branch if no TMSS chip
	move.l #'SEGA',($A14000);A14000 disable TMSS
NoTmss:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;					Set Up Graphics

	lea VDPSettings,A5		;Initialize Screen Registers
	move.l #VDPSettingsEnd-VDPSettings,D1 ;length of Settings

	move.w (VDP_ctrl),D0	;C00004 read VDP status (interrupt acknowledge?)
	move.l #$00008000,d5	;VDP Reg command (%8rvv)

NextInitByte:
	move.b (A5)+,D5			;get next video control byte
	move.w D5,(VDP_ctrl)	;C00004 send write register command to VDP
		;   8RVV - R=Reg V=Value
	add.w #$0100,D5			;point to next VDP register
	dbra D1,NextInitByte	;loop for rest of block

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;					Set up palette and graphics

	move.l #$C0000000,d0	;Color 0
	move.l d0,VDP_Ctrl
	MOVE.W #$0A00,VDP_Data		;BLUE

	move.l #$C01E0000,d0	;Color 0
	move.l d0,VDP_Ctrl
	MOVE.W #$00EE,VDP_Data		;YELLOW

	lea Graphics,a0						;background tiles
	move.w #(GraphicsEnd-Graphics)-1,d1	;data size
	CLR.L D2							;start loading at tile 0 of VRAM
	jsr DefineTiles

	clr.b Cursor_X			;Clear Cursor XY
	clr.b Cursor_Y

	;Turn on screen
	move.w	#$8144,(VDP_Ctrl);C00004 reg 1 = 0x44 unblank display

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; TESTING AREA

	;load the tilemaps
	LEA Conway_Tilemap,a3
	LEA ConwayTilemapRam,A2
	move.l #(Conway_Backup_Tilemap-Conway_Tilemap),d1
	JSR LDIR

	LEA Conway_Backup_Tilemap,a3
	LEA conwayBackupTilemapRam,A2
	move.l #(Conway_Backup_Tilemap-Conway_Tilemap),d1
	JSR LDIR

	CLR.B Cursor_X
	CLR.B Cursor_Y
	;print the tilemap once
	LEA ConwayTilemapRam,A3
	JSR Conway_Print

main:

	;do the behavior
	jsr Conway_CheckTilemap

	;copy the tilemap
	lea conwayBackupTilemapRam,A3
	LEA ConwayTilemapRam,A2
	move.l #(Conway_Backup_Tilemap-Conway_Tilemap),d1
	jsr LDIR

	CLR.B Cursor_X
	CLR.B Cursor_Y
	;print the tilemap
	LEA ConwayTilemapRam,A3
	JSR Conway_Print

	;repeat
	JMP main

Conway_CheckTilemap:

	;since we don't want the partial results of the checks to mess with later ones, we'll copy the changes to a buffer, and then
	;have that buffer clobber the original. That way, all changes to the ecosystem are effectively atomic.

	LEA ConwayTilemapRam,A0
	LEA conwayBackupTilemapRam,A6
	LEA (ROWLENGTH+3,A0),A0	;actual data starts here
	LEA (ROWLENGTH+3,A6),A6	;actual data starts here
.loop:
	MOVE.B (A0),D2
	CMP.B #255,D2
	BEQ .done
	CMP.B #2,D2
	BEQ .overhead
	JSR Conway_CheckNeighbors

	pushLong D0
		JSR popcnt_8
		MOVE.B D0,D3
	popLong D0

	;now implement the table here.
	;neighbor bits in D0
	;current state in D2
	;popcnt in D3
	;pointer to where we are in A0

	;the only time the current state is relevant to the output, is when popcnt = 2. Otherwise, it's entirely determined by popcnt.
	CMP.B #4,D3
	BCC .DeadCell
	CMP.B #1,D3
	BLS .DeadCell
	CMP.B #3,D3
	BEQ .LiveCell
	;else, must be 2.
	MOVE.B D2,(A6)	;store current value into backup table.
	bra .overhead
.LiveCell:
	MOVE.B #1,(A6)
	BRA .overhead
.DeadCell:
	MOVE.B #0,(A6)	;store in backup table.
.overhead:
	ADDA.L #1,A0
	ADDA.L #1,A6
	JMP .loop
.done:
	RTS

popcnt_8:
	pushRegs D2-D5
		MOVEQ #8-1,D5
		MOVEQ #0,D3
.loop:
		ROR.B #1,D0
		BCC .overhead
			ADDQ.B #1,D3
.overhead:
		dbra d5,.loop
	MOVE.B D3,D0
	popRegs D2-D5
	RTS

Conway_CheckNeighbors:
	;A0 = pointer to where we are in the tilemap.
	;returns: D0.B = uUrRdDlL
	;u = top left
	;U = top
	;r = top Right
	;R = Right
	;d = bottom right
	;D = bottom
	;l = bottom Left
	;L = Left
	pushRegs D2-D5/A0
	MOVEQ #0,D0
	MOVE.L A0,A1
	MOVE.L A1,A2
	SUBA.L #ROWLENGTH+2,A1		;POINTS ABOVE
	ADDA.L #ROWLENGTH+2,A2		;POINTS BELOW

	MOVE.B (A1),D1
	MOVE.B (A2),D2

	CMP.B #1,D1
	BNE .noUpper
	BSET #6,D0
	bra .next
.noUpper:
	BCLR #6,D0
.next:
CheckLower:
	CMP.B #1,D2
	BNE .noLower
	BSET #2,D0
	bra .next
.noLower:
	BCLR #2,D0
.next:

	SUBA.L #1,A0	;left
	SUBA.L #1,A1	;upper-left
	SUBA.L #1,A2	;lower-left

	MOVE.B (A1),D1
	MOVE.B (A2),D2
	MOVE.B (A0),D3
CheckUpperLeft:
	CMP.B #1,D1
	BNE .noUpperLeft
	BSET #7,D0
	bra .next
.noUpperLeft:
	BCLR #7,D0
.next:

CheckLowerLeft:
	CMP.B #1,D2
	BNE .noLowerLeft
	BSET #1,D0
	bra .next
.noLowerLeft:
	BCLR #1,D0
.next:

CheckLeft:
	CMP.B #1,D3
	BNE .noLeft
	BSET #0,D0
	bra .next
.noLeft:
	BCLR #0,D0
.next:

	addA.L #2,A0
	addA.L #2,A1
	addA.L #2,A2

	MOVE.B (A1),D1
	MOVE.B (A2),D2
	MOVE.B (A0),D3

CheckUpperRight:
	CMP.B #1,D1
	BNE .noUpperRight
	BSET #5,D0
	bra .next
.noUpperRight:
	BCLR #5,D0
.next:

CheckLowerRight:
	CMP.B #1,D2
	BNE .noLowerRight
	BSET #3,D0
	bra .next
.noLowerRight:
	BCLR #3,D0
.next:

CheckRight:
	CMP.B #1,D3
	BNE .noRight
	BSET #4,D0
	bra .next
.noRight:
	BCLR #4,D0
.next:
	popRegs D2-D5/A0
	rts

Conway_Print:
	;input: A3 = base address of tilemap
	MOVE.B (A3)+,D0
	CMP.B #255,D0
	BEQ .done
	CMP.B #2,D0
	BEQ .skip
	;else, print
	JSR Conway_PrintChar
.skip
	BRA Conway_Print
.done
	rts

Conway_PrintChar:				;Show D0 to screen
	moveM.l d0-d7/a0-a7,-(sp)
		and.l #$FF,d0			;Keep only 1 byte
		Move.L  #$40000003,d5	;top 4=write, bottom $3=Cxxx range
		MOVEQ #0,D4				;Tilemap at $C000+

		Move.B (Cursor_Y),D4
		rol.L #8,D4				;move $-FFF to $-FFF----
		rol.L #8,D4
		rol.L #7,D4				;2 bytes per tile * 64 tiles per line
		add.L D4,D5				;add $4------3

		Move.B (Cursor_X),D4
		rol.L #8,D4				;move $-FFF to $-FFF----
		rol.L #8,D4
		rol.L #1,D4				;2 bytes per tile
		add.L D4,D5				;add $4------3

		MOVE.L	D5,(VDP_ctrl)	; C00004 write next character to VDP
		MOVE.W	D0,(VDP_data)	; C00000 store next word of name data

		addq.b #1,(Cursor_X)	;INC Xpos
		move.b (Cursor_X),d0
		cmp.b #39,d0
		bls .nextpixel_Xok
		jsr NewLine			;If we're at end of line, start newline
.nextpixel_Xok:
	moveM.l (sp)+,d0-d7/a0-a7
	rts

;don't forget, these are in ROM so we can't write to them directly.
;instead, they will be copied to ram and worked with from there.
Conway_Tilemap:	;(screenwidth + 2) by (screenheight+2)
	DC.B $02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$01,$01,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$01,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$01,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$01,$01,$00,$00,$00,$00,$00,$00,$01,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$01,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$01,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	DC.B $02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02
	DC.B 255
	EVEN
Conway_Backup_Tilemap:	;(screenwidth + 2) by (screenheight+2)
	DC.B $02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02
	rept 30
	DC.B $02,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$02
	endr
	DC.B $02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02,$02
	DC.B 255
	EVEN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
NewLine:
	addq.b #1,(Cursor_Y)		;INC Y
	clr.b (Cursor_X)			;Zero X
	rts

LDIR:	;COPY D1 BYTES FROM A3 TO A2
	move.b (a3)+,(a2)+
	DBRA D1,LDIR
	rts

DefineTiles:						;Copy D1 bytes of data from A0 to VDP memory D2
	jsr prepareVram					;Calculate the memory location we want to write
.again:								; the tile pattern definitions to
		move.l (a0)+,(VDP_data)
		dbra d1,.again
	rts

prepareVram:							;To select a memory location D2 we need to calculate
										;the command byte... depending on the memory location
	pushall								;$7FFF0003 = Vram $FFFF.... $40000000=Vram $0000
		move.l d2,d0
		and.w #%1100000000000000,d0		;Shift the top two bits to the far right
		rol.w #2,d0

		and.l #%0011111111111111,d2	    ; shift all the other bits left two bytes
		rol.l #8,d2
		rol.l #8,d2

		or.l d0,d2
		or.l #$40000000,d2				;Set the second bit from the top to 1
										;#%01000000 00000000 00000000 00000000
		move.l d2,(VDP_ctrl)
popallRTS:
	popall
	rts

Graphics:
	DC.L $0000000F,$0000000F,$0000000F,$0000000F,$0000000F,$0000000F,$0000000F,$FFFFFFFF
	DC.L $FFFFFFFF,$FFFFFFFF,$FFFFFFFF,$FFFFFFFF,$FFFFFFFF,$FFFFFFFF,$FFFFFFFF,$FFFFFFFF
GraphicsEnd:

VDPSettings:
	DC.B $04 ; 0 mode register 1											---H-1M-
	DC.B $04 ; 1 mode register 2											-DVdP---
	DC.B $30 ; 2 name table base for scroll A (A=top 3 bits)				--AAA--- = $C000
	DC.B $3C ; 3 name table base for window (A=top 4 bits / 5 in H40 Mode)	--AAAAA- = $F000
	DC.B $07 ; 4 name table base for scroll B (A=top 3 bits)				-----AAA = $E000
	DC.B $6C ; 5 sprite attribute table base (A=top 7 bits / 6 in H40)		-AAAAAAA = $D800
	DC.B $00 ; 6 unused register											--------
	DC.B $00 ; 7 background color (P=Palette C=Color)						--PPCCCC
	DC.B $00 ; 8 unused register											--------
	DC.B $00 ; 9 unused register											--------
	DC.B $FF ;10 H interrupt register (L=Number of lines)					LLLLLLLL
	DC.B $00 ;11 mode register 3											----IVHL
	DC.B $81 ;12 mode register 4 (C bits both1 = H40 Cell)					C---SIIC
	DC.B $37 ;13 H scroll table base (A=Top 6 bits)							--AAAAAA = $FC00
	DC.B $00 ;14 unused register											--------
	DC.B $02 ;15 auto increment (After each Read/Write)						NNNNNNNN
	DC.B $01 ;16 scroll size (Horiz & Vert size of ScrollA & B)				--VV--HH = 64x32 tiles
	DC.B $00 ;17 window H position (D=Direction C=Cells)					D--CCCCC
	DC.B $00 ;18 window V position (D=Direction C=Cells)					D--CCCCC
	DC.B $FF ;19 DMA length count low										LLLLLLLL
	DC.B $FF ;20 DMA length count high										HHHHHHHH
	DC.B $00 ;21 DMA source address low										LLLLLLLL
	DC.B $00 ;22 DMA source address mid										MMMMMMMM
	DC.B $80 ;23 DMA source address high (C=CMD)							CCHHHHHH
VDPSettingsEnd:
	even


num: 2

if? num=2 [
	print "yep, num is 2"
]
else [
	print "something went wrong..."
]


*&---------------------------------------------------------------------*
*& Report ZCONWAYS_GAME_OF_LIFE
*&---------------------------------------------------------------------*
*& by Marcelo Bovo
*&---------------------------------------------------------------------*
report zconways_game_of_life line-size 174 no standard page heading
                             line-count 40.

parameters: p_char type c default '#',
            p_pos  type string.

class lcl_game_of_life definition.

  public section.

    data: x_max      type i value 174,
          y_max      type i value 40,
          character  type c value abap_true,
          x          type i,
          y          type i,
          pos        type string,
          offlimits  type i value 9998,
          grid(9999) type c. " every X_MAX characters on grid equals one line on screen

    data: o_random_y type ref to cl_abap_random_int,
          o_random_x type ref to cl_abap_random_int.

    methods: constructor,
      play,
      initial_position,
      initial_grid,
      write,
      change_grid.

endclass.

class lcl_game_of_life implementation.
  method constructor.
    o_random_y = cl_abap_random_int=>create( seed = cl_abap_random=>create( conv i( sy-uzeit ) )->intinrange( low = 1 high = 999999 )
                                             min  = 1
                                             max = y_max ).

    o_random_x = cl_abap_random_int=>create( seed = cl_abap_random=>create( conv i( |{ sy-datum(4) }{ sy-uzeit }| ) )->intinrange( low = 1 high = 999999 )
                                             min  = 1
                                             max = x_max ).

  endmethod.

  method play.

    "fill initial data ramdonly if user hasnt typed any coordenates
    if pos is initial.
      initial_position( ).
    endif.

    initial_grid( ).

    write( ).

  endmethod.

  method initial_position.
    do cl_abap_random_int=>create( "seed = conv i( sy-uzeit )
                                   min  = 50
                                   max = 800 )->get_next( ) times.
      data(lv_index) = sy-index.

      x = o_random_x->get_next( ).
      y = o_random_y->get_next( ).

      p_pos = |{ p_pos }{ switch char1( lv_index when '1' then space else ';' ) }{ y },{ x }|.
    enddo.
  endmethod.

  method initial_grid.

    "Split coordenates
    split p_pos at ';' into table data(lt_pos_inicial) .

    "Sort By Line(Easy to read)
    sort lt_pos_inicial.

    loop at lt_pos_inicial assigning field-symbol(<pos_inicial>).

      split <pos_inicial> at ',' into data(y_char) data(x_char).

      x = x_char.
      y = y_char.

      "Ensure maximum coordenates are not surpassed
      x = cond #( when x <= x_max then x
                   else o_random_x->get_next( ) ).

      y = cond #( when y <= y_max then y
                   else o_random_y->get_next( ) ).

      "Write on string grid
      "Every x_max lines represent one line(Y) on the grid
      data(grid_xy) = ( x_max * y ) + x - x_max - 1.
      grid+grid_xy(1) = character.

    endloop.

  endmethod.

  method write.

    skip to line 1.

    "Write every line on screen
    do y_max times.
      data(lv_index) = sy-index - 1.

      "Write whole line(current line plus number of maximum X characters)
      data(grid_xy) = ( lv_index * x_max ).

      write / grid+grid_xy(x_max) no-gap.

      if grid+grid_xy(x_max) is initial.
        skip.
      endif.

    enddo.

    change_grid( ).

  endmethod.

  method change_grid.

    data(grid_aux) = grid.
    clear grid_aux.
    data(grid_size) = strlen( grid ).

    "Validate neighbours based on previous written grid
    "ABC
    "D.F
    "GHI
    do grid_size + x_max times.

      "Doens't write anything beyond borders
      check sy-index <= x_max * y_max.

      data(grid_xy) = sy-index - 1.

      data(neighbours) = 0.

      "Current Line neighbours
      data(d) = grid_xy - 1.
      data(f) = grid_xy + 1.

      "Line above neighbours
      data(b) = grid_xy - x_max.
      data(a) = b - 1.
      data(c) = b + 1.

      "Line Bellow neighbours
      data(h) = grid_xy + x_max.
      data(g) = h - 1.
      data(i) = h + 1.

      "Previous Neighbours
      neighbours += cond #( when a < 0 then 0 else cond #( when grid+a(1) is not initial then 1 else 0 )   ).
      neighbours += cond #( when b < 0 then 0 else cond #( when grid+b(1) is not initial then 1 else 0 )   ).
      neighbours += cond #( when c < 0 then 0 else cond #( when grid+c(1) is not initial then 1 else 0 )   ).
      neighbours += cond #( when d < 0 then 0 else cond #( when grid+d(1) is not initial then 1 else 0 )   ).

      "Next Neighbours
      neighbours += cond #( when f > grid_size then 0 else cond #( when grid+f(1) is not initial then 1 else 0 )   ).
      neighbours += cond #( when g > grid_size then 0 else cond #( when grid+g(1) is not initial then 1 else 0 )   ).
      neighbours += cond #( when h > grid_size then 0 else cond #( when grid+h(1) is not initial then 1 else 0 )   ).
      neighbours += cond #( when i > grid_size then 0 else cond #( when grid+i(1) is not initial then 1 else 0 )   ).

      grid_aux+grid_xy(1) = cond #( when  neighbours = 3 or (  neighbours = 2  and grid+grid_xy(1) = character )
                                     then character
                                    else space ).

    enddo.

    grid = grid_aux.

  endmethod.
endclass.

start-of-selection.

  set pf-status 'STANDARD_FULLSCREEN'. "Use &REFRESH button with F8 Shortcut to go to next generation

  data(lo_prog) = new lcl_game_of_life( ).
  lo_prog->character = p_char.
  lo_prog->pos = p_pos.
  lo_prog->play( ).

at user-command.

  case sy-ucomm.
    when 'REFR' or '&REFRESH'.
      sy-lsind = 1. "Prevents LIST_TOO_MANY_LEVELS DUMP
      lo_prog->write( ).
    when others.
      leave list-processing.
  endcase.


if x == 0:
    foo()
elif x == 1:
    bar()
elif x == 2:
    baz()
else:
    qux()

match x:
    0 => foo()
    1 => bar()
    2 => baz()
    _ => qux()

(a) ? b : c


(defun print-row (row)
   (if (endp row)
       nil
       (prog2$ (if (first row)
                   (cw "[]")
                   (cw "  "))
               (print-row (rest row)))))

(defun print-grid-r (grid)
   (if (endp grid)
       nil
       (progn$ (cw "|")
               (print-row (first grid))
               (cw "|~%")
               (print-grid-r (rest grid)))))

(defun print-line (l)
   (if (zp l)
       nil
       (prog2$ (cw "-")
               (print-line (1- l)))))

(defun print-grid (grid)
   (progn$ (cw "+")
           (print-line (* 2 (len (first grid))))
           (cw "+~%")
           (print-grid-r grid)
           (cw "+")
           (print-line (* 2 (len (first grid))))
           (cw "+~%")))

(defun neighbors-row-r (row)
   (if (endp (rest (rest row)))
       (list (if (first row) 1 0))
       (cons (+ (if (first row) 1 0)
                (if (third row) 1 0))
             (neighbors-row-r (rest row)))))

(defun neighbors-row (row)
   (cons (if (second row) 1 0)
         (neighbors-row-r row)))

(defun zip+ (xs ys)
   (if (or (endp xs) (endp ys))
       (append xs ys)
       (cons (+ (first xs) (first ys))
             (zip+ (rest xs) (rest ys)))))

(defun counts-row (row)
   (if (endp row)
       nil
       (cons (if (first row) 1 0)
             (counts-row (rest row)))))

(defun neighbors-r (grid prev-counts curr-counts next-counts
                         prev-neighbors curr-neighbors
                         next-neighbors)
   (if (endp (rest grid))
       (list (zip+ (zip+ prev-counts
                         prev-neighbors)
                   (neighbors-row (first grid))))
       (cons (zip+ (zip+ (zip+ prev-counts next-counts)
                         (zip+ prev-neighbors next-neighbors))
                   curr-neighbors)
             (neighbors-r (rest grid)
                          curr-counts
                          next-counts
                          (counts-row (third grid))
                          curr-neighbors
                          next-neighbors
                          (neighbors-row (third grid))))))

(defun neighbors (grid)
   (neighbors-r grid
                nil
                (counts-row (first grid))
                (counts-row (second grid))
                nil
                (neighbors-row (first grid))
                (neighbors-row (second grid))))

(defun life-rules-row (life neighbors)
   (if (or (endp life) (endp neighbors))
       nil
       (cons (or (and (first life)
                      (or (= (first neighbors) 2)
                          (= (first neighbors) 3)))
                 (and (not (first life))
                      (= (first neighbors) 3)))
             (life-rules-row (rest life) (rest neighbors)))))

(defun life-rules-r (grid neighbors)
   (if (or (endp grid) (endp neighbors))
       nil
       (cons (life-rules-row (first grid) (first neighbors))
             (life-rules-r (rest grid) (rest neighbors)))))

(defun conway-step (grid)
   (life-rules-r grid (neighbors grid)))

(defun conway (grid steps)
   (if (zp steps)
       nil
       (progn$ (print-grid grid)
               (conway (conway-step grid) (1- steps)))))


x = 1
If x
  MsgBox, x is %x%
Else If x > 1
  MsgBox, x is %x%
Else
  MsgBox, x is %x%


WITH Ada.Text_IO;  USE Ada.Text_IO;

PROCEDURE Life IS
   SUBTYPE Cell IS Natural RANGE 0 .. 1;

   TYPE Petri_Dish IS ARRAY (Positive RANGE <>, Positive RANGE <>) OF Cell;

   PROCEDURE Step (Gen : IN OUT Petri_Dish) IS
      Above       : ARRAY (Gen'Range (2)) OF Cell := (OTHERS => 0);
      Left, This  : Cell;
   BEGIN
      FOR I IN Gen'First (1) + 1 .. Gen'Last (1) - 1 LOOP
         Left := 0;
         FOR J IN Gen'First (2) + 1 .. Gen'Last (2) - 1 LOOP
            This := (CASE Above (J - 1) + Above (J) + Above (J + 1) +
                          Left			    + Gen (I, J + 1) +
                          Gen (I + 1, J - 1) + Gen (I + 1, J) 	+ Gen (I + 1, J + 1) IS
                        WHEN 2      => Gen (I, J),
                        WHEN 3      => 1,
                        WHEN OTHERS => 0);
            Above (J - 1):= Left;
            Left         := Gen (I, J);
            Gen (I, J) 	 := This;
         END LOOP;
         Above (Above'Last - 1) := Left;
      END LOOP;
   END Step;

   PROCEDURE Put (Gen : Petri_Dish) IS
   BEGIN
      FOR I IN Gen'Range (1) LOOP
         FOR J IN Gen'Range (2) LOOP
            Put ( if Gen (I, J) = 0 then " " else "#");
         END LOOP;
         New_Line;
      END LOOP;
   END Put;

   Blinker : Petri_Dish := (2 .. 4 => (0, 0, 1, 0, 0), 1 | 5 => (0, 0, 0, 0, 0));
   Glider  : Petri_Dish (1..6,1..11):= (2 => (3 => 1, others => 0),
                                        3 => (4 => 1, others => 0),
                                        4 => (2|3|4=>1, others => 0),
                                        others => (others => 0));
   PROCEDURE Put_And_Step_Generation (N : Positive; Name : String; P : IN OUT Petri_Dish) IS
   BEGIN
      FOR Generation IN 1 .. N LOOP
         Put_Line (Name & Generation'Img);
         Put (P);
         Step (P);
      END LOOP;
   END Put_And_Step_Generation;

BEGIN
   Put_And_Step_Generation (3, "Blinker", Blinker);
   Put_And_Step_Generation (5, "Glider", Glider);
END Life;


If <expression> Then
    statements
    ...
[ElseIf expression-n Then
    [elseif statements ... ]]
    ...
[Else
    [else statements]
    ...
EndIf


If year = 1999 then [Print: "Party!";];

If someNumber > 5 then [Print: "Too high!";] else [Print: "Adequate amount.";];

If breed = "Abyssinian" then [score := 150;]
else if breed = "Birman" then [score := 70;]
else [score := 45;];

Unless char = ¢X then [Print: "character was not an x";];


use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation" -- For the regex at the top of newUniverse()
use scripting additions

-- The characters to represent the live and dead cells.
property live : "■" -- character id 9632 (U+25A0).
property dead : space
-- Infinite universes are expensive to maintain, so only a local region of universe is represented here.
-- Its invisible border is a wall of "dead" cells one cell deep, lined with a two-cell buffer layer into which
-- objects nominally leaving the region can disappear without being seen to hit the wall or bouncing back.
property borderThickness : 3

on newUniverse(seed, {w, h})
    -- Replace every visible character in the seed text with "■" and every horizontal space with a space.
    set seed to current application's class "NSMutableString"'s stringWithString:(seed)
    set regex to current application's NSRegularExpressionSearch
    tell seed to replaceOccurrencesOfString:("\\S") withString:(live) options:(regex) range:({0, its |length|()})
    tell seed to replaceOccurrencesOfString:("\\h") withString:(dead) options:(regex) range:({0, its |length|()})
    -- Ensure the universe dimensions are at least equal to the number of lines and the length of the longest.
    set seedLines to paragraphs of (seed as text)
    set lineCount to (count seedLines)
    if (lineCount > h) then set h to lineCount
    set seedWidth to 0
    repeat with thisLine in seedLines
        set lineLength to (count thisLine)
        if (lineLength > seedWidth) then set seedWidth to lineLength
    end repeat
    if (seedWidth > w) then set w to seedWidth

    -- Get a new universe.
    script universe
        -- State lists. These will contain or be lists of 0s and 1s and will include the border cells.
        property newState : {}
        property previousState : {}
        property currentRow : {}
        property rowAbove : {}
        property rowBelow : {}
        property replacementRow : {}
        -- Equivalent text lists. These will only cover what's in the bounded region.
        property lineList : {}
        property characterGrid : {}
        property currentLineCharacters : {}
        -- Precalculated border cell indices.
        property rightInnerBuffer : borderThickness + w + 1
        property rightOuterBuffer : rightInnerBuffer + borderThickness - 2
        property bottomInnerBuffer : borderThickness + h + 1
        property bottomOuterBuffer : bottomInnerBuffer + borderThickness - 2
        -- Generation counter.
        property counter : 0
        -- Temporary lists used in the set-up.
        property rowTemplate : {}
        property lineCharacterTemplate : {}

        -- Built-in handlers. Both return text representing a universe state and
        -- a boolean indicating whether or not the state's the same as the previous one.
        on nextState()
            set astid to AppleScript's text item delimiters
            set AppleScript's text item delimiters to ""
            copy newState to previousState
            set currentRow to beginning of my previousState
            set rowBelow to item 2 of my previousState
            -- Check each occupiable cell in each occupiable row of the 'previousState' grid, including the buffer cells.
            -- If warranted by the number of live neighbours, edit the equivalent cell in 'newState' and,
            -- if within the region's bounds, change the corresponding text character too.
            repeat with r from 2 to bottomOuterBuffer
                set rowAbove to currentRow
                set currentRow to rowBelow
                set rowBelow to item (r + 1) of my previousState
                set replacementRow to item r of my newState
                set rowCrossesRegion to ((r comes after borderThickness) and (r comes before bottomInnerBuffer))
                if (rowCrossesRegion) then set currentLineCharacters to item (r - borderThickness) of my characterGrid
                set lineChanged to false
                repeat with c from 2 to rightOuterBuffer
                    set liveNeighbours to ¬
                        (item (c - 1) of my rowAbove) + (item c of my rowAbove) + (item (c + 1) of my rowAbove) + ¬
                        (item (c - 1) of my currentRow) + (item (c + 1) of my currentRow) + ¬
                        (item (c - 1) of my rowBelow) + (item c of my rowBelow) + (item (c + 1) of my rowBelow)
                    if (item c of my currentRow is 1) then
                        if ((liveNeighbours < 2) or (liveNeighbours > 3)) then
                            set item c of my replacementRow to 0
                            if ((c comes after borderThickness) and (c comes before rightInnerBuffer) and (rowCrossesRegion)) then
                                set item (c - borderThickness) of my currentLineCharacters to dead
                                set lineChanged to true
                            else if ((c is 3) or (c is rightOuterBuffer) or (r is 3) or (r is bottomOuterBuffer)) then
                                -- This is a fudge to dissolve "bombers" entering the buffer zone.
                                set item (c - 1) of my replacementRow to -1
                                set item c of item (r - 1) of my newState to -1
                            end if
                        end if
                    else if (liveNeighbours is 3) then
                        set item c of my replacementRow to 1
                        if ((c comes after borderThickness) and (c comes before rightInnerBuffer) and (rowCrossesRegion)) then
                            set item (c - borderThickness) of my currentLineCharacters to live
                            set lineChanged to true
                        end if
                    end if
                end repeat
                if (lineChanged) then set item (r - borderThickness) of my lineList to currentLineCharacters as text
            end repeat
            set AppleScript's text item delimiters to astid
            set counter to counter + 1
            set last item of my lineList to "Generation " & counter

            return currentState()
        end nextState

        on currentState()
            set noChanges to (newState = previousState)
            if (noChanges) then ¬
                set last item of my lineList to (last item of my lineList) & " (all dead, still lifes, or left the universe)"
            set astid to AppleScript's text item delimiters
            set AppleScript's text item delimiters to return
            set stateText to lineList as text
            set AppleScript's text item delimiters to astid

            return {stateText, noChanges}
        end currentState
    end script

    -- Set the universe's start conditions.
    -- Build a row template list containing w + 2 * borderThickness zeros
    -- and a line character template list containing w 'dead' characters.
    repeat (borderThickness * 2) times
        set end of universe's rowTemplate to 0
    end repeat
    repeat w times
        set end of universe's rowTemplate to 0
        set end of universe's lineCharacterTemplate to dead
    end repeat
    set astid to AppleScript's text item delimiters
    set AppleScript's text item delimiters to ""
    set blankLine to universe's lineCharacterTemplate as text

    -- Use the templates to populate lists representing the universe's conditions.
    -- Firstly the top border rows ('newState' list only).
    repeat borderThickness times
        copy universe's rowTemplate to end of universe's newState
    end repeat
    -- Then enough rows and text lines to centre the input roughly halfway down the grid.
    set headroom to (h - lineCount) div 2
    repeat headroom times
        copy universe's rowTemplate to end of universe's newState
        copy universe's lineCharacterTemplate to end of universe's characterGrid
        set end of universe's lineList to blankLine
    end repeat
    -- Then the rows and lines representing the input itself, centring it roughly halfway across the grid.
    set textInset to (w - seedWidth) div 2
    set stateInset to textInset + borderThickness
    repeat with thisLine in seedLines
        copy universe's rowTemplate to universe's currentRow
        copy universe's lineCharacterTemplate to universe's currentLineCharacters
        repeat with c from 1 to (count thisLine)
            set thisCharacter to character c of thisLine
            set item (textInset + c) of universe's currentLineCharacters to thisCharacter
            set item (stateInset + c) of universe's currentRow to (thisCharacter is live) as integer
        end repeat
        set end of universe's newState to universe's currentRow
        set end of universe's characterGrid to universe's currentLineCharacters
        set end of universe's lineList to universe's currentLineCharacters as text
    end repeat
    set AppleScript's text item delimiters to astid
    -- Then the rows and lines beneath and the bottom border.
    repeat (h - (headroom + lineCount)) times
        copy universe's rowTemplate to end of universe's newState
        copy universe's lineCharacterTemplate to end of universe's characterGrid
        set end of universe's lineList to blankLine
    end repeat
    repeat borderThickness times
        copy universe's rowTemplate to end of universe's newState
    end repeat
    -- Add a generation counter display line to the end of the line list.
    set end of universe's lineList to "Generation 0"
    -- Lose the no-longer-needed template lists.
    set universe's rowTemplate to missing value
    set universe's lineCharacterTemplate to universe's rowTemplate

    return universe
end newUniverse


	.string "PRG"

	lcd_ptr .req r4
	active_fb .req r5
	inactive_fb .req r6
	offset_r .req r7
	backup_fb .req r8

	@ start
	push {r4-r10, r12, lr}

	ldr lcd_ptr, =0xC0000000 @ address of the LCD controller
	adr offset_r, offsets
	ldrh r0, [offset_r, #6] @ 0xffff is already in memory because -1 is in the offsets table
	str r0, [lcd_ptr, #0x200] @ set up paletted colors: 1 is black, 0 is white

	ldr r2, [lcd_ptr, #0x18] @ load lcd configuration
	bic r2, #14
	orr r2, #6 @ Set color mode to 8 bpp, paletted
	str r2, [lcd_ptr, #0x18]

	ldr backup_fb, [lcd_ptr, #0x10] @ Save address of OS framebuffer

	@ allocate a buffer for game state / framebuffer
	ldr r0, =153600 @ 320 * 240 * 2
	add r0, #8
	svc #5 @ malloc
	push {r0}
	orr inactive_fb, r0, #7
	add inactive_fb, #1
	add active_fb, inactive_fb, #76800

	@ fill buffer with random ones and zeroes
	ldr r10, =76800
	mov r9, #0
1:	subs r10, r10, #1
	strb r9, [active_fb, r10] @ zero other framebuffer
	svc #206 @ rand syscall
	and r0, r0, #1
	strb r0, [inactive_fb, r10]
	bne 1b

	@ set first and last rows to zero
	mov r2, #320
	mov r1, #0
	mov r0, inactive_fb
	push {r1,r2}
	svc #7 @ memset
	pop {r1,r2}
	ldr r3, =76480
	add r0, r0, r3
	svc #7

	@ beginning of main loop, swap framebuffers
3:	ldr r0, =76480 @ 320 * 239
	str inactive_fb, [lcd_ptr, #0x10]
	mov inactive_fb, active_fb
	ldr active_fb, [lcd_ptr, #0x10]

	@ per-pixel loop
2:	mov r1, #16 @ 8 * 2
	mov r2, #0
	sub r0, #1

	@ loop to count up neighboring living cells
1:	subs r1, #2
	ldrsh r3, [offset_r, r1] @ cant use lsl #1
	add r3, r3, r0
	ldrb r3, [active_fb, r3]
	add r2, r2, r3
	bne 1b @ at end of loop, r1 and r3 can be discarded

	@ decides whether the cell should live or die based on neighbors
	ldrb r1, [active_fb, r0]
	add r2, r2, r1
	teq r2, #3
	moveq r1, #1
	teqne r2, #4
	movne r1, #0
	strb r1, [inactive_fb, r0]
	teq r0, #320
	bne 2b

	@ checks if the escape key is pressed
	ldr r0, =0x900E001C
	ldr r1, [r0]
	tst r1, #0x80
	beq 3b

	str backup_fb, [lcd_ptr, #0x10] @ restores OS framebuffer

	pop {r0}
	svc #6 @ free buffer
	pop {r4-r10, r12, pc}
offsets:
	.hword -321, -320, -319, -1, 1, 319, 320, 321


rows := cols := 10                               ; set grid dimensions
i = -1,0,1, -1,1, -1,0,1                         ; neighbors' x-offsets
j = -1,-1,-1, 0,0, 1,1,1                         ; neighbors' y-offsets
StringSplit i, i, `,                             ; make arrays
StringSplit j, j, `,

Loop % rows {                                    ; setup grid of checkboxes
   r := A_Index, y := r*17-8                     ; looks good in VISTA
   Loop % cols {
      c := A_Index, x := c*17-5
      Gui Add, CheckBox, x%x% y%y% w17 h17 vv%c%_%r% gCheck
   }
}
Gui Add, Button, % "x12 w" x+2, step             ; button to step to next generation
Gui Show
Return

Check:
   GuiControlGet %A_GuiControl%                  ; manual set of cells
Return

ButtonStep:                                      ; move to next generation
   Loop % rows {
      r := A_Index
      Loop % cols {
         c := A_Index, n := 0
         Loop 8                                  ; w[x,y] <- new states
            x := c+i%A_Index%, y := r+j%A_Index%, n += 1=v%x%_%y%
         GuiControl,,v%c%_%r%,% w%c%_%r% := v%c%_%r% ? n=2 || n=3 : n=3
      }
   }
   Loop % rows {                                 ; update v[x,y] = states
      r := A_Index
      Loop % cols
         v%A_Index%_%r% := w%A_Index%_%r%
   }
Return

GuiClose:                                        ; exit when GUI is closed
ExitApp


10 LET A%=1: REM A HAS A VALUE OF TRUE
20 IF A% THEN PRINT "A IS TRUE"
30 WE CAN OF COURSE USE EXPRESSIONS
40 IF A%<>0 THEN PRINT "A IS TRUE"
50 IF NOT(A%) THEN PRINT "A IS FALSE"
60 REM SOME VERSIONS OF BASIC PROVIDE AN ELSE KEYWORD
70 IF A% THEN PRINT "A IS TRUE" ELSE PRINT "A IS FALSE"


# Begin Case / Case / End Case, Do / Until, If Then, While / End While

begin case
   case boolean_expr
      statement(s)
   case boolean_expr
      statement(s)
   else
      statement(s)
end case

do
   statement(s)
until boolean_expr

if booleanexpr then
   statement(s)
end if

if booleanexpr then
   statement(s)
else
   statement(s)
end if

while boolean_expr
   statement(s)
end while


IF [NOT] ERRORLEVEL number          command
IF [NOT] string1==string2           command
IF [NOT] EXIST filename             command
IF CMDEXTVERSION number             command
IF DEFINED variable                 command
IF [/I] string1 compare-op string2  command
   where compare-op is:
   EQU - equal
   NEQ - not equal
   LSS - less than
   LEQ - less than or equal
   GTR - greater than
   GEQ - greater than or equal
   /I    case insensitive string compares


Full

While getKey(0)
End

ClrDraw
.BLINKER
Pxl-On(45,45)
Pxl-On(46,45)
Pxl-On(47,45)

.GLIDER
Pxl-On(1,1)
Pxl-On(2,2)
Pxl-On(2,3)
Pxl-On(3,1)
Pxl-On(3,2)

Repeat getKey(0)
 DispGraph
 EVOLVE()
 RecallPic
 ClrDrawʳ
End
Return

Lbl EVOLVE
For(Y,0,63)
 For(X,0,95)
  0→N
  For(B,Y-1,Y+1)
   For(A,X-1,X+1)
    pxl-Test(A,B)?N++
   End
  End
  pxl_Test(X,Y)?N--
  If N=3??(N=2?pxl-Test(X,Y))
   Pxl-On(X,Y)ʳ
  Else
   Pxl-Off(X,Y)ʳ
  End
 End
End
Return


      REM Single-line IF ... THEN ... ELSE (ELSE clause is optional):
      IF condition% THEN statements ELSE statements

      REM Multi-line IF ... ENDIF (ELSE clause is optional):
      IF condition% THEN
        statements
      ELSE
        statements
      ENDIF

      REM CASE ... ENDCASE (OTHERWISE clause is optional):
      CASE expression OF
        WHEN value1: statements
        WHEN value2: statements
          ...
        OTHERWISE: statements
      ENDCASE

      REM ON ... GOTO (ELSE clause is optional):
      ON expression% GOTO dest1, dest2 ... ELSE statements

      REM ON ...GOSUB (ELSE clause is optional):
      ON expression% GOSUB dest1, dest2 ... ELSE statements

      REM ON ... PROC (ELSE clause is optional):
      ON expression% PROCone, PROCtwo ... ELSE statements


# Conway's_Game_of_Life

X = 59 : Y = 35 : H = 4

fastgraphics
graphsize X*H,Y*H

dim c(X,Y) : dim cn(X,Y) : dim cl(X,Y)


'      lstack top value == 0 ? skip next instruction : don’t skip next instruction.
"      lstack top value  > 0 ? skip next instruction : don’t skip next instruction.
K      lstack top value == 2nd value ? skip next instruction : don’t skip next instruction.
L      lstack top value  > 2nd value ? skip next instruction : don’t skip next instruction.


@echo off
setlocal enabledelayedexpansion

if "%1"=="" (
  call:_blinkerArray
) else (
  call:_randomArray %*
)

for /l %%i in (1,1,%iterations%) do (
  call:_setStatus
  call:_display

  for /l %%m in (1,1,%m%) do (
    for /l %%n in (1,1,%m%) do (
      call:_evolution %%m %%n
    )
  )
)

:_blinkerArray
for /l %%m in (0,1,4) do (
  for /l %%n in (0,1,4) do (
    set cell[%%m][%%n]=0
  )
)
set cell[2][1]=1
set cell[2][2]=1
set cell[2][3]=1
set iterations=5
set m=3
set cellsaddone=4

exit /b

:_randomArray
set cellsaddone=%1+1
for /l %%m in (0,1,%cellsaddone%) do for /l %%n in (0,1,%cellsaddone%) do set cell[%%m][%%n]=0
for /l %%m in (1,1,%1) do (
  for /l %%n in (1,1,%1) do (
    set /a cellrandom=!random! %% 101
    set cell[%%m][%%n]=0
    if !cellrandom! leq %2 set cell[%%m][%%n]=1
  )
)
set iterations=%3
set m=%1

exit /b

:_setStatus
for /l %%m in (0,1,%cellsaddone%) do (
  for /l %%n in (0,1,%cellsaddone%) do (
    if !cell[%%m][%%n]!==1 set cellstatus[%%m][%%n]=alive
    if !cell[%%m][%%n]!==0 set cellstatus[%%m][%%n]=dead
  )
)
exit /b

:_evolution
set /a lowerm=%1-1
set /a upperm=%1+1
set /a lowern=%2-1
set /a uppern=%2+1
set numm=%1
set numn=%2
set sum=0
for /l %%m in (%lowerm%,1,%upperm%) do (
  for /l %%n in (%lowern%,1,%uppern%) do (
    if %%m==%numm% (
      if %%n==%numn% (
        set /a sum=!sum!
      ) else (
        if !cellstatus[%%m][%%n]!==alive set /a sum+=1
      )
    ) else (
      if !cellstatus[%%m][%%n]!==alive set /a sum+=1
    )
  )
)
goto:!cell[%numm%][%numn%]!

exit /b

:0
set alive=3
set death=0 1 2 4 5 6 7 8
for %%i in (%alive%) do if %sum%==%%i set cell[%numm%][%numn%]=1
for %%i in (%death%) do if %sum%==%%i set cell[%numm%][%numn%]=0
exit /b

:1
set alive=2 3
set death=0 1 4 5 6 7 8
for %%i in (%alive%) do if %sum%==%%i set cell[%1][%2]=1
for %%i in (%death%) do if %sum%==%%i set cell[%1][%2]=0
exit /b

:_display
echo.
for /l %%m in (1,1,%m%) do (
  set m%%m=
  for /l %%n in (1,1,%m%) do set m%%m=!m%%m! !cell[%%m][%%n]!
  echo !m%%m!
)

exit /b


if i % 2 == 0
    print("even")
else
    print("odd")
end


if (i == 0)
    return "zero";
elif (i % 2)
    return "odd";
else
    return "even";


If      ← {𝕏⍟𝕎@}´                 # Also Repeat
IfElse  ← {c‿T‿F: c◶F‿[email protected]}
While   ← {𝕩{𝔽⍟𝔾∘𝔽_𝕣_𝔾∘𝔽⍟𝔾𝕩}𝕨@}´  # While 1‿{... to run forever
DoWhile ← {𝕏@ ⋄ While 𝕨‿𝕩}´
For     ← {I‿C‿P‿A: [email protected] ⋄ While⟨C,P∘A⟩}

# Switch/case statements have many variations; these are a few
Match   ← {𝕏𝕨}´
Select  ← {(⊑𝕩)◶(1↓𝕩)@}
Switch  ← {c←⊑𝕩 ⋄ m‿a←<˘⍉∘‿2⥊1↓𝕩 ⋄ (⊑a⊐C)◶[email protected]}
Test    ← {fn←{C‿A𝕊e:C◶A‿E}´𝕩⋄[email protected]}


width = 3
height = 3
rounds = 3

universe = [[0 1 0]
            [0 1 0]
            [0 1 0]]

next = height.of({width.of(0)})

cell = { x, y |
  true? x < width && { x >= 0 && { y >= 0 && { y < height }}}
  {
    universe[y][x]
  }
  { 0 }
}

neighbors = { x, y |
  cell(x - 1, y - 1) +
  cell(x, y - 1) +
  cell(x + 1, y - 1) +
  cell(x + 1, y) +
  cell(x + 1, y + 1) +
  cell(x, y + 1) +
  cell(x - 1, y + 1) +
  cell(x - 1, y)
}

set_next = { x, y, v |
  next[y][x] = v
}

step = {
  universe.each_with_index { row, y |
    row.each_with_index { c, x |
      n = neighbors(x, y)

      when { n < 2 } { set_next x,y, 0 }
           { n > 3 } { set_next x, y, 0 }
           { n == 3 } { set_next x, y, 1 }
           { true } { set_next x, y, c }
    }
  }

  u2 = universe
  universe = next
  next = u2
}

display = {
  p universe.map({ r |
    r.map({ n | true? n == 0, '-', "O" }).join
  }).join("\n")
}

rounds.times {
  display
  p
  step
}


    2+2:5
  & put$"Strange, must check that Bracmat interpreter."
  & 0
|   put$"That's what I thought."
  & Right


Life←{
   r←¯1(⌽⎉1)¯1⌽(2+≢𝕩)↑𝕩
   s←∨´ (1∾<r) ∧ 3‿4 = <+´⥊ ¯1‿0‿1 (⌽⎉1)⌜ ¯1‿0‿1 ⌽⌜ <r
   1(↓⎉1) ¯1(↓⎉1) 1↓ ¯1↓s
}

blinker←>⟨0‿0‿0,1‿1‿1,0‿0‿0⟩
(<".#") ⊏¨˜  Life⍟(↕3) blinker


if (condition)
{
   // Some Task
}

if (condition)
{
  // Some Task
}
else if (condition2)
{
  // Some Task
}
else
{
  // Some Task
}


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define for_x for (int x = 0; x < w; x++)
#define for_y for (int y = 0; y < h; y++)
#define for_xy for_x for_y
void show(void *u, int w, int h)
{
	int (*univ)[w] = u;
	printf("\033[H");
	for_y {
		for_x printf(univ[y][x] ? "\033[07m  \033[m" : "  ");
		printf("\033[E");
	}
	fflush(stdout);
}

void evolve(void *u, int w, int h)
{
	unsigned (*univ)[w] = u;
	unsigned new[h][w];

	for_y for_x {
		int n = 0;
		for (int y1 = y - 1; y1 <= y + 1; y1++)
			for (int x1 = x - 1; x1 <= x + 1; x1++)
				if (univ[(y1 + h) % h][(x1 + w) % w])
					n++;

		if (univ[y][x]) n--;
		new[y][x] = (n == 3 || (n == 2 && univ[y][x]));
	}
	for_y for_x univ[y][x] = new[y][x];
}

void game(int w, int h)
{
	unsigned univ[h][w];
	for_xy univ[y][x] = rand() < RAND_MAX / 10 ? 1 : 0;
	while (1) {
		show(univ, w, h);
		evolve(univ, w, h);
		usleep(200000);
	}
}

int main(int c, char **v)
{
	int w = 0, h = 0;
	if (c > 1) w = atoi(v[1]);
	if (c > 2) h = atoi(v[2]);
	if (w <= 0) w = 30;
	if (h <= 0) h = 30;
	game(w, h);
}


template<bool Condition, typename ThenType, typename Elsetype> struct ifthenelse;

template<typename ThenType, typename ElseType> struct ifthenelse<true, ThenType, ElseType>
{
  typedef ThenType type;
};

template<typename ThenType, typename ElseType> struct ifthenelse<false, ThenType, ElseType>
{
  typedef ElseType type;
};

// example usage: select type based on size
ifthenelse<INT_MAX == 32767, // 16 bit int?
           long int,         // in that case, we'll need a long int
           int>              // otherwise an int will do
  ::type myvar;              // define variable myvar with that type


using System;
using System.Text;
using System.Threading;

namespace ConwaysGameOfLife
{
    // Plays Conway's Game of Life on the console with a random initial state.
    class Program
    {
        // The delay in milliseconds between board updates.
        private const int DELAY = 50;

        // The cell colors.
        private const ConsoleColor DEAD_COLOR = ConsoleColor.White;
        private const ConsoleColor LIVE_COLOR = ConsoleColor.Black;

        // The color of the cells that are off of the board.
        private const ConsoleColor EXTRA_COLOR = ConsoleColor.Gray;

        private const char EMPTY_BLOCK_CHAR = ' ';
        private const char FULL_BLOCK_CHAR = '\u2588';

        // Holds the current state of the board.
        private static bool[,] board;

        // The dimensions of the board in cells.
        private static int width = 32;
        private static int height = 32;

        // True if cell rules can loop around edges.
        private static bool loopEdges = true;

        static void Main(string[] args)
        {
            // Use initializeRandomBoard for a larger, random board.
            initializeDemoBoard();

            initializeConsole();

            // Run the game until the Escape key is pressed.
            while (!Console.KeyAvailable || Console.ReadKey(true).Key != ConsoleKey.Escape) {
                Program.drawBoard();
                Program.updateBoard();

                // Wait for a bit between updates.
                Thread.Sleep(DELAY);
            }
        }

        // Sets up the Console.
        private static void initializeConsole()
        {
            Console.BackgroundColor = EXTRA_COLOR;
            Console.Clear();

            Console.CursorVisible = false;

            // Each cell is two characters wide.
            // Using an extra row on the bottom to prevent scrolling when drawing the board.
            int width = Math.Max(Program.width, 8) * 2 + 1;
            int height = Math.Max(Program.height, 8) + 1;
            Console.SetWindowSize(width, height);
            Console.SetBufferSize(width, height);

            Console.BackgroundColor = DEAD_COLOR;
            Console.ForegroundColor = LIVE_COLOR;
        }

        // Creates the initial board with a random state.
        private static void initializeRandomBoard()
        {
            var random = new Random();

            Program.board = new bool[Program.width, Program.height];
            for (var y = 0; y < Program.height; y++) {
                for (var x = 0; x < Program.width; x++) {
                    // Equal probability of being true or false.
                    Program.board[x, y] = random.Next(2) == 0;
                }
            }
        }

        // Creates a 3x3 board with a blinker.
        private static void initializeDemoBoard()
        {
            Program.width = 3;
            Program.height = 3;

            Program.loopEdges = false;

            Program.board = new bool[3, 3];
            Program.board[1, 0] = true;
            Program.board[1, 1] = true;
            Program.board[1, 2] = true;
        }

        // Draws the board to the console.
        private static void drawBoard()
        {
            // One Console.Write call is much faster than writing each cell individually.
            var builder = new StringBuilder();

            for (var y = 0; y < Program.height; y++) {
                for (var x = 0; x < Program.width; x++) {
                    char c = Program.board[x, y] ? FULL_BLOCK_CHAR : EMPTY_BLOCK_CHAR;

                    // Each cell is two characters wide.
                    builder.Append(c);
                    builder.Append(c);
                }
                builder.Append('\n');
            }

            // Write the string to the console.
            Console.SetCursorPosition(0, 0);
            Console.Write (builder.ToString());
        }

        // Moves the board to the next state based on Conway's rules.
        private static void updateBoard()
        {
            // A temp variable to hold the next state while it's being calculated.
            bool[,] newBoard = new bool[Program.width, Program.height];

            for (var y = 0; y < Program.height; y++) {
                for (var x = 0; x < Program.width; x++) {
                    var n = countLiveNeighbors(x, y);
                    var c = Program.board[x, y];

                    // A live cell dies unless it has exactly 2 or 3 live neighbors.
                    // A dead cell remains dead unless it has exactly 3 live neighbors.
                    newBoard[x, y] = c && (n == 2 || n == 3) || !c && n == 3;
                }
            }

            // Set the board to its new state.
            Program.board = newBoard;
        }

        // Returns the number of live neighbors around the cell at position (x,y).
        private static int countLiveNeighbors(int x, int y)
        {
            // The number of live neighbors.
            int value = 0;

            // This nested loop enumerates the 9 cells in the specified cells neighborhood.
            for (var j = -1; j <= 1; j++) {
                // If loopEdges is set to false and y+j is off the board, continue.
                if (!Program.loopEdges && y + j < 0 || y + j >= Program.height) {
                    continue;
                }

                // Loop around the edges if y+j is off the board.
                int k = (y + j + Program.height) % Program.height;

                for (var i = -1; i <= 1; i++) {
                    // If loopEdges is set to false and x+i is off the board, continue.
                    if (!Program.loopEdges && x + i < 0 || x + i >= Program.width) {
                        continue;
                    }

                    // Loop around the edges if x+i is off the board.
                    int h = (x + i + Program.width) % Program.width;

                    // Count the neighbor cell at (h,k) if it is alive.
                    value += Program.board[h, k] ? 1 : 0;
                }
            }

            // Subtract 1 if (x,y) is alive since we counted it as a neighbor.
            return value - (Program.board[x, y] ? 1 : 0);
        }
    }
}


IF x == 1
   SomeFunc1()
ELSEIF x == 2
   SomeFunc2()
ELSE
   SomeFunc()
ENDIF


#include <iostream>
#define HEIGHT 4
#define WIDTH 4

struct Shape {
public:
    char xCoord;
    char yCoord;
    char height;
    char width;
    char **figure;
};

struct Glider : public Shape {
    static const char GLIDER_SIZE = 3;
    Glider( char x , char y );
    ~Glider();
};

struct Blinker : public Shape {
    static const char BLINKER_HEIGHT = 3;
    static const char BLINKER_WIDTH = 1;
    Blinker( char x , char y );
    ~Blinker();
};

class GameOfLife {
public:
    GameOfLife( Shape sh );
    void print();
    void update();
    char getState( char state , char xCoord , char yCoord , bool toggle);
    void iterate(unsigned int iterations);
private:
    char world[HEIGHT][WIDTH];
    char otherWorld[HEIGHT][WIDTH];
    bool toggle;
    Shape shape;
};

GameOfLife::GameOfLife( Shape sh ) :
    shape(sh) ,
    toggle(true)
{
    for ( char i = 0; i < HEIGHT; i++ ) {
        for ( char j = 0; j < WIDTH; j++ ) {
            world[i][j] = '.';
        }
    }
    for ( char i = shape.yCoord; i - shape.yCoord < shape.height; i++ ) {
        for ( char j = shape.xCoord; j - shape.xCoord < shape.width; j++ ) {
            if ( i < HEIGHT && j < WIDTH ) {
                world[i][j] =
                    shape.figure[ i - shape.yCoord ][j - shape.xCoord ];
            }
        }
    }
}

void GameOfLife::print() {
    if ( toggle ) {
        for ( char i = 0; i < HEIGHT; i++ ) {
            for ( char j = 0; j < WIDTH; j++ ) {
                std::cout << world[i][j];
            }
            std::cout << std::endl;
        }
    } else {
        for ( char i = 0; i < HEIGHT; i++ ) {
            for ( char j = 0; j < WIDTH; j++ ) {
                std::cout << otherWorld[i][j];
            }
            std::cout << std::endl;
        }
    }
    for ( char i = 0; i < WIDTH; i++ ) {
        std::cout << '=';
    }
    std::cout << std::endl;
}

void GameOfLife::update() {
    if (toggle) {
        for ( char i = 0; i < HEIGHT; i++ ) {
            for ( char j = 0; j < WIDTH; j++ ) {
                otherWorld[i][j] =
                    GameOfLife::getState(world[i][j] , i , j , toggle);
            }
        }
        toggle = !toggle;
    } else {
        for ( char i = 0; i < HEIGHT; i++ ) {
            for ( char j = 0; j < WIDTH; j++ ) {
                world[i][j] =
                    GameOfLife::getState(otherWorld[i][j] , i , j , toggle);
            }
        }
        toggle = !toggle;
    }
}

char GameOfLife::getState( char state, char yCoord, char xCoord, bool toggle ) {
    char neighbors = 0;
    if ( toggle ) {
        for ( char i = yCoord - 1; i <= yCoord + 1; i++ ) {
            for ( char j = xCoord - 1; j <= xCoord + 1; j++ ) {
                if ( i == yCoord && j == xCoord ) {
                    continue;
                }
                if ( i > -1 && i < HEIGHT && j > -1 && j < WIDTH ) {
                    if ( world[i][j] == 'X' ) {
                        neighbors++;
                    }
                }
            }
        }
    } else {
        for ( char i = yCoord - 1; i <= yCoord + 1; i++ ) {
            for ( char j = xCoord - 1; j <= xCoord + 1; j++ ) {
                if ( i == yCoord && j == xCoord ) {
                    continue;
                }
                if ( i > -1 && i < HEIGHT && j > -1 && j < WIDTH ) {
                    if ( otherWorld[i][j] == 'X' ) {
                        neighbors++;
                    }
                }
            }
        }
    }
    if (state == 'X') {
        return ( neighbors > 1 && neighbors < 4 ) ? 'X' : '.';
    }
    else {
        return ( neighbors == 3 ) ? 'X' : '.';
    }
}

void GameOfLife::iterate( unsigned int iterations ) {
    for ( int i = 0; i < iterations; i++ ) {
        print();
        update();
    }
}

Glider::Glider( char x , char y ) {
    xCoord = x;
    yCoord = y;
    height = GLIDER_SIZE;
    width = GLIDER_SIZE;
    figure = new char*[GLIDER_SIZE];
    for ( char i = 0; i < GLIDER_SIZE; i++ ) {
        figure[i] = new char[GLIDER_SIZE];
    }
    for ( char i = 0; i < GLIDER_SIZE; i++ ) {
        for ( char j = 0; j < GLIDER_SIZE; j++ ) {
            figure[i][j] = '.';
        }
    }
    figure[0][1] = 'X';
    figure[1][2] = 'X';
    figure[2][0] = 'X';
    figure[2][1] = 'X';
    figure[2][2] = 'X';
}

Glider::~Glider() {
    for ( char i = 0; i < GLIDER_SIZE; i++ ) {
        delete[] figure[i];
    }
    delete[] figure;
}

Blinker::Blinker( char x , char y ) {
    xCoord = x;
    yCoord = y;
    height = BLINKER_HEIGHT;
    width = BLINKER_WIDTH;
    figure = new char*[BLINKER_HEIGHT];
    for ( char i = 0; i < BLINKER_HEIGHT; i++ ) {
        figure[i] = new char[BLINKER_WIDTH];
    }
    for ( char i = 0; i < BLINKER_HEIGHT; i++ ) {
        for ( char j = 0; j < BLINKER_WIDTH; j++ ) {
            figure[i][j] = 'X';
        }
    }
}

Blinker::~Blinker() {
    for ( char i = 0; i < BLINKER_HEIGHT; i++ ) {
        delete[] figure[i];
    }
    delete[] figure;
}

int main() {
    Glider glider(0,0);
    GameOfLife gol(glider);
    gol.iterate(5);
    Blinker blinker(1,0);
    GameOfLife gol2(blinker);
    gol2.iterate(4);
}


(if (= 1 1) :yes :no) ; returns :yes

(if (= 1 2) :yes :no) ; returns :no

(if (= 1 2) :yes) ; returns nil


config const gridHeight: int = 3;
config const gridWidth: int = 3;

enum State { dead = 0, alive = 1 };

class ConwaysGameofLife {

  var gridDomain: domain(2);
  var computeDomain: subdomain( gridDomain );
  var grid: [gridDomain] int;

  proc ConwaysGameofLife( height: int, width: int ) {
    this.gridDomain = {0..#height+2, 0..#width+2};
    this.computeDomain = this.gridDomain.expand( -1 );
  }

  proc step(){

    var tempGrid: [this.computeDomain] State;
    forall (i,j) in this.computeDomain {
      var isAlive = this.grid[i,j] == State.alive;
      var numAlive = (+ reduce this.grid[ i-1..i+1, j-1..j+1 ]) - if isAlive then 1 else 0;
      tempGrid[i,j] = if ( (2 == numAlive && isAlive) || numAlive == 3 ) then State.alive else State.dead ;
    }

    this.grid[this.computeDomain] = tempGrid;

  }

  proc this( i: int, j: int ) ref : State {
    return this.grid[i,j];
  }

  proc prettyPrint(): string {
    var str: string;
    for i in this.gridDomain.dim(1) {
      if i == 0 || i == gridDomain.dim(1).last {
        for j in this.gridDomain.dim(2) {
          str += "-";
        }
      } else {
        for j in this.gridDomain.dim(2) {
          if j == 0 || j == this.gridDomain.dim(2).last {
            str += "|";
          } else {
            str += if this.grid[i,j] == State.alive then "#" else " ";
          }
        }
      }
      str += "\n";
    }
    return str;
  }

}

proc main{
  var game = new ConwaysGameofLife( gridHeight, gridWidth );
  game[gridHeight/2 + 1, gridWidth/2     ] = State.alive;
  game[gridHeight/2 + 1, gridWidth/2 + 1 ] = State.alive;
  game[gridHeight/2 + 1, gridWidth/2 + 2 ] = State.alive;
  for i in 1..3 {
    writeln( game.prettyPrint() );
    game.step();
  }
}


set(num 5)

if(num GREATER 100)
  message("${num} is very large!")
elseif(num GREATER 10)
  message("${num} is large.")
else()
  message("${num} is small.")
  message("We might want a bigger number.")
endif()


(defn moore-neighborhood [[x y]]
  (for [dx [-1 0 1]
        dy [-1 0 1]
        :when (not (= [dx dy] [0 0]))]
    [(+ x dx) (+ y dy)]))

(defn step [set-of-cells]
  (set (for [[cell count] (frequencies (mapcat moore-neighborhood set-of-cells))
             :when (or (= 3 count)
                       (and (= 2 count) (contains? set-of-cells cell)))]
         cell)))

(defn print-world
  ([set-of-cells] (print-world set-of-cells 10))
  ([set-of-cells world-size]
     (let [r (range 0 (+ 1 world-size))]
       (pprint (for [y r] (apply str (for [x r] (if (set-of-cells [x y]) \# \.))))))))

(defn run-life [world-size num-steps set-of-cells]
  (loop [s num-steps
         cells set-of-cells]
    (print-world cells world-size)
    (when (< 0 s)
      (recur (- s 1) (step cells)))))

(def *blinker* #{[1 2] [2 2] [3 2]})
(def *glider* #{[1 0] [2 1] [0 2] [1 2] [2 2]})


if condition-1
    imperative-statement-1
else
    imperative-statement-2
end-if

if condition-1
    if condition-a
        imperative-statement-1a
    else
        imperative-statement-1
    end-if
else
    if condition-a
        imperative-statement-2a
    else
        imperative-statement-2
    end-if
end-if


identification division.
program-id. game-of-life-program.
data division.
working-storage section.
01  grid.
    05 cell-table.
        10 row occurs 5 times.
            15 cell pic x value space occurs 5 times.
    05 next-gen-cell-table.
        10 next-gen-row occurs 5 times.
            15 next-gen-cell pic x occurs 5 times.
01  counters.
    05 generation pic 9.
    05 current-row pic 9.
    05 current-cell pic 9.
    05 living-neighbours pic 9.
    05 neighbour-row pic 9.
    05 neighbour-cell pic 9.
    05 check-row pic s9.
    05 check-cell pic s9.
procedure division.
control-paragraph.
    perform blinker-paragraph varying current-cell from 2 by 1
    until current-cell is greater than 4.
    perform show-grid-paragraph through life-paragraph
    varying generation from 0 by 1
    until generation is greater than 2.
    stop run.
blinker-paragraph.
    move '#' to cell(3,current-cell).
show-grid-paragraph.
    display 'GENERATION ' generation ':'.
    display '   +---+'.
    perform show-row-paragraph varying current-row from 2 by 1
    until current-row is greater than 4.
    display '   +---+'.
    display ''.
life-paragraph.
    perform update-row-paragraph varying current-row from 2 by 1
    until current-row is greater than 4.
    move next-gen-cell-table to cell-table.
show-row-paragraph.
    display '   |' with no advancing.
    perform show-cell-paragraph varying current-cell from 2 by 1
    until current-cell is greater than 4.
    display '|'.
show-cell-paragraph.
    display cell(current-row,current-cell) with no advancing.
update-row-paragraph.
    perform update-cell-paragraph varying current-cell from 2 by 1
    until current-cell is greater than 4.
update-cell-paragraph.
    move 0 to living-neighbours.
    perform check-row-paragraph varying check-row from -1 by 1
    until check-row is greater than 1.
    evaluate living-neighbours,
        when 2 move cell(current-row,current-cell) to next-gen-cell(current-row,current-cell),
        when 3 move '#' to next-gen-cell(current-row,current-cell),
        when other move space to next-gen-cell(current-row,current-cell),
    end-evaluate.
check-row-paragraph.
    add check-row to current-row giving neighbour-row.
    perform check-cell-paragraph varying check-cell from -1 by 1
    until check-cell is greater than 1.
check-cell-paragraph.
    add check-cell to current-cell giving neighbour-cell.
    if cell(neighbour-row,neighbour-cell) is equal to '#',
    and check-cell is not equal to zero or check-row is not equal to zero,
    then add 1 to living-neighbours.


if n == 1
  console.log "one"
else if n == 2
  console.log "two"
else
  console.log "other"


(defun next-life (array &optional results)
  (let* ((dimensions (array-dimensions array))
         (results (or results (make-array dimensions :element-type 'bit))))
    (destructuring-bind (rows columns) dimensions
      (labels ((entry (row col)
                 "Return array(row,col) for valid (row,col) else 0."
                 (if (or (not (< -1 row rows))
                         (not (< -1 col columns)))
                   0
                   (aref array row col)))
               (neighbor-count (row col &aux (count 0))
                 "Return the sum of the neighbors of (row,col)."
                 (dolist (r (list (1- row) row (1+ row)) count)
                   (dolist (c (list (1- col) col (1+ col)))
                     (unless (and (eql r row) (eql c col))
                       (incf count (entry r c))))))
               (live-or-die? (current-state neighbor-count)
                 (if (or (and (eql current-state 1)
                              (<=  2 neighbor-count 3))
                         (and (eql current-state 0)
                              (eql neighbor-count 3)))
                   1
                   0)))
        (dotimes (row rows results)
          (dotimes (column columns)
            (setf (aref results row column)
                  (live-or-die? (aref array row column)
                                (neighbor-count row column)))))))))

(defun print-grid (grid &optional (out *standard-output*))
  (destructuring-bind (rows columns) (array-dimensions grid)
    (dotimes (r rows grid)
      (dotimes (c columns (terpri out))
        (write-char (if (zerop (aref grid r c)) #\+ #\#) out)))))

(defun run-life (&optional world (iterations 10) (out *standard-output*))
  (let* ((world (or world (make-array '(10 10) :element-type 'bit)))
         (result (make-array (array-dimensions world) :element-type 'bit)))
    (do ((i 0 (1+ i))) ((eql i iterations) world)
      (terpri out) (print-grid world out)
      (psetq world (next-life world result)
             result world))))


<cfif x eq 3>
 do something
<cfelseif x eq 4>
 do something else
<cfelse>
 do something else
</cfif>


import std.stdio, std.string, std.algorithm, std.array, std.conv;

struct GameOfLife {
  enum Cell : char { dead = ' ', alive = '#' }
  Cell[][] grid, newGrid;

  this(in int x, in int y) pure nothrow @safe {
    grid = new typeof(grid)(y + 2, x + 2);
    newGrid = new typeof(grid)(y + 2, x + 2);
  }

  void opIndexAssign(in string[] v, in size_t y, in size_t x)
  pure /*nothrow*/ @safe /*@nogc*/ {
    foreach (immutable nr, row; v)
      foreach (immutable nc, state; row)
        grid[y + nr][x + nc] = state.to!Cell;
  }

  void iteration() pure nothrow @safe @nogc {
    newGrid[0][] = Cell.dead;
    newGrid[$ - 1][] = Cell.dead;
    foreach (row; newGrid)
      row[0] = row[$ - 1] = Cell.dead;

    foreach (immutable r; 1 .. grid.length - 1)
      foreach (immutable c; 1 .. grid[0].length - 1) {
        uint count = 0;
        foreach (immutable i; -1 .. 2)
          foreach (immutable j; -1 .. 2)
            if (i != 0 || j != 0)
              count += grid[r + i][c + j] == Cell.alive;
        immutable a = count == 3 ||
                      (count == 2 && grid[r][c] == Cell.alive);
        newGrid[r][c] = a ? Cell.alive : Cell.dead;
      }

    grid.swap(newGrid);
  }

  string toString() const pure /*nothrow @safe*/ {
    auto ret = "-".replicate(grid[0].length - 1) ~ "\n";
    foreach (const row; grid[1 .. $ - 1])
      ret ~= "|%(%c%)|\n".format(row[1 .. $ - 1]);
    return ret ~ "-".replicate(grid[0].length - 1);
  }
}

void main() /*@safe*/ {
  immutable glider1 = ["  #", "# #", " ##"];
  immutable glider2 = ["#  ", "# #", "## "];

  auto uni = GameOfLife(60, 20);
  uni[3,  2] = glider1;
  uni[3, 15] = glider2;
  uni[3, 19] = glider1;
  uni[3, 32] = glider2;
  uni[5, 50] = [" #  #", "#  ", "#   #", "#### "];
  uni.writeln;

  foreach (immutable _; 0 .. 20) {
    uni.iteration;
    uni.writeln;
  }
}


/**
* States of a cell. A cell is either [ALIVE] or [DEAD].
* The state contains its [symbol] for printing.
*/
class State {
  const State(this.symbol);

  static final ALIVE = const State('#');
  static final DEAD = const State(' ');

  final String symbol;
}

/**
* The "business rule" of the game. Depending on the count of neighbours,
* the [cellState] changes.
*/
class Rule {
  Rule(this.cellState);

  reactToNeighbours(int neighbours) {
    if (neighbours == 3) {
      cellState = State.ALIVE;
    } else if (neighbours != 2) {
      cellState = State.DEAD;
    }
  }

  var cellState;
}

/**
* A coordinate on the [Grid].
*/
class Point {
  const Point(this.x, this.y);

  operator +(other) => new Point(x + other.x, y + other.y);

  final int x;
  final int y;
}

/**
* List of the relative indices of the 8 cells around a cell.
*/
class Neighbourhood {
  List<Point> points() {
    return [
      new Point(LEFT, UP), new Point(MIDDLE, UP), new Point(RIGHT, UP),
      new Point(LEFT, SAME), new Point(RIGHT, SAME),
      new Point(LEFT, DOWN), new Point(MIDDLE, DOWN), new Point(RIGHT, DOWN)
    ];
  }

  static final LEFT = -1;
  static final MIDDLE = 0;
  static final RIGHT = 1;
  static final UP = -1;
  static final SAME = 0;
  static final DOWN = 1;
}

/**
* The grid is an endless, two-dimensional [field] of cell [State]s.
*/
class Grid {
  Grid(this.xCount, this.yCount) {
    _field = new Map();
    _neighbours = new Neighbourhood().points();
  }

  set(point, state) {
    _field[_pos(point)] = state;
  }

  State get(point) {
    var state = _field[_pos(point)];
    return state != null ? state : State.DEAD;
  }

  int countLiveNeighbours(point) =>
    _neighbours.filter((offset) => get(point + offset) == State.ALIVE).length;

  _pos(point) => '${(point.x + xCount) % xCount}:${(point.y + yCount) % yCount}';

  print() {
    var sb = new StringBuffer();
    iterate((point) { sb.add(get(point).symbol); }, (x) { sb.add("\n"); });
    return sb.toString();
  }

  iterate(eachCell, [finishedRow]) {
    for (var x = 0; x < xCount; x++) {
      for (var y = 0; y < yCount; y++) {
         eachCell(new Point(x, y));
      }
      if(finishedRow != null) {
        finishedRow(x);
      }
    }
  }

  final xCount, yCount;
  List<Point> _neighbours;
  Map<String, State> _field;
}

/**
* The game updates the [grid] in each step using the [Rule].
*/
class Game {
  Game(this.grid);

  tick() {
    var newGrid = createNewGrid();

    grid.iterate((point) {
      var rule = new Rule(grid.get(point));
      rule.reactToNeighbours(grid.countLiveNeighbours(point));
      newGrid.set(point, rule.cellState);
    });

    grid = newGrid;
  }

  createNewGrid() => new Grid(grid.xCount, grid.yCount);

  printGrid() => print(grid.print());

  Grid grid;
}

main() {
  // Run the GoL with a blinker.
  runBlinker();
}

runBlinker() {
  var game = new Game(createBlinkerGrid());

  for(int i = 0; i < 3; i++) {
    game.printGrid();
    game.tick();
  }
  game.printGrid();
}

createBlinkerGrid() {
  var grid = new Grid(4, 4);
  loadBlinker(grid);
  return grid;
}

loadBlinker(grid) => blinkerPoints().forEach((point) => grid.set(point, State.ALIVE));

blinkerPoints() => [new Point(0, 1), new Point(1, 1), new Point(2, 1)];


(if (= val 42)
    "That is the answer to life, the universe and everything"
    "Try again") ; the else clause here is optional


if (condition)
{
   // Some Task
}

if (condition)
{
  // Some Task
}
else if (condition2)
{
  // Some Task
}
else
{
  // Some Task
}


program game_of_life;

{$APPTYPE CONSOLE}

uses
  System.SysUtils,
  Velthuis.Console; // CrlScr

type
  TBoolMatrix = TArray<TArray<Boolean>>;

  TField = record
    s: TBoolMatrix;
    w, h: Integer;
    procedure SetValue(x, y: Integer; b: boolean);
    function Next(x, y: Integer): boolean;
    function State(x, y: Integer): boolean;
    class function NewField(w1, h1: Integer): TField; static;
  end;

  TLife = record
    a, b: TField;
    w, h: Integer;
    class function NewLife(w1, h1: Integer): TLife; static;
    procedure Step;
    function ToString: string;
  end;

{ TField }

class function TField.NewField(w1, h1: Integer): TField;
var
  s1: TBoolMatrix;
begin
  SetLength(s1, h1);
  for var i := 0 to High(s1) do
    SetLength(s1[i], w1);
  with Result do
  begin
    s := s1;
    w := w1;
    h := h1;
  end;
end;

function TField.Next(x, y: Integer): boolean;
var
  _on: Integer;
begin
  _on := 0;
  for var i := -1 to 1 do
    for var j := -1 to 1 do
      if self.State(x + i, y + j) and not ((j = 0) and (i = 0)) then
        inc(_on);
  Result := (_on = 3) or (_on = 2) and self.State(x, y);
end;

procedure TField.SetValue(x, y: Integer; b: boolean);
begin
  self.s[y, x] := b;
end;

function TField.State(x, y: Integer): boolean;
begin
  while y < 0 do
    inc(y, self.h);
  while x < 0 do
    inc(x, self.w);
  result := self.s[y mod self.h, x mod self.w]
end;

{ TLife }

class function TLife.NewLife(w1, h1: Integer): TLife;
var
  a1: TField;
begin
  a1 := TField.NewField(w1, h1);
  for var i := 0 to (w1 * h1 div 2) do
    a1.SetValue(Random(w1), Random(h1), True);
  with Result do
  begin
    a := a1;
    b := TField.NewField(w1, h1);
    w := w1;
    h := h1;
  end;
end;

procedure TLife.Step;
var
  tmp: TField;
begin
  for var y := 0 to self.h - 1 do
    for var x := 0 to self.w - 1 do
      self.b.SetValue(x, y, self.a.Next(x, y));
  tmp := self.a;
  self.a := self.b;
  self.b := tmp;
end;

function TLife.ToString: string;
begin
  result := '';
  for var y := 0 to self.h - 1 do
  begin
    for var x := 0 to self.w - 1 do
    begin
      var b: char := ' ';
      if self.a.State(x, y) then
        b := '*';
      result := result + b;
    end;
    result := result + #10;
  end;
end;

begin
  Randomize;

  var life := TLife.NewLife(80, 15);

  for var i := 1 to 300 do
  begin
    life.Step;
    ClrScr;
    writeln(life.ToString);
    sleep(30);
  end;
  readln;
end.


void main() {
    enum int i = 5;

    // "static if" for various static checks:
    static if (i == 7) {
        // ...
    } else {
        //...
    }

    // is(T == U) checks if type T is U.
    static if (is(typeof(i) == int)) {
        // ...
    } else {
        // ...
    }

    // D switch is improved over C switch:
    switch (i) {
        case 0:
            break; // Silent fallthrough is forbidden.
        case 1:
            goto case; // Explicit fallthrough.
        case 2:
            // Empty cases don't require an explicit fallthrough.
        case 3:
            return;
        case 4, 5, 7: // Multiple cases.
            break;
        case 8: .. case 15: // Inclusive interval.
            goto case 3;
        default: // Default case is required.
            break;
    }

    enum Colors { yellow, blue, brown, green }
    immutable c = Colors.blue;

    // "final switch" is safer, for enums (and in future other values,
    // like Algebraic), because all cases must be present.
    // with() is handy to avoid repeating "Colors." for each case.
    final switch (c) with (Colors) {
        case yellow:        break;
        case blue:          break;
        case brown, green:  break;
        // case yellow: .. case brown: // Forbidden in final switches.
        // default: // Forbidden in final switches.
    }
}


def gridWidth := 3
def gridHeight := 3
def X := 0..!gridWidth
def Y := 0..!gridHeight

def makeFlexList := <elib:tables.makeFlexList>
def makeGrid() {
  def storage := makeFlexList.fromType(<type:java.lang.Boolean>, gridWidth * gridHeight)
  storage.setSize(gridWidth * gridHeight)

  def grid {
    to __printOn(out) {
      for y in Y {
        out.print("[")
        for x in X {
          out.print(grid[x, y].pick("#", " "))
        }
        out.println("]")
      }
    }
    to get(xb :int, yb :int) {
      return if (xb =~ x :X && yb =~ y :Y) {
        storage[y * gridWidth + x]
      } else {
        false
      }
    }
    to put(x :X, y :Y, c :boolean) {
      storage[y * gridWidth + x] := c
    }
  }
  return grid
}

def mooreNeighborhood := [[-1,-1],[0,-1],[1,-1],[-1,0],[1,0],[-1,1],[0,1],[1,1]]
def computeNextLife(prevGrid, nextGrid) {
  for y in Y {
    for x in X {
      var neighbors := 0
      for [nx, ny] ? (prevGrid[x+nx, y+ny]) in mooreNeighborhood {
        neighbors += 1
      }
      def self := prevGrid[x, y]
      nextGrid[x, y] := (self && neighbors == 2 || neighbors == 3)
    }
  }
}

var currentFrame := makeGrid()
var nextFrame := makeGrid()
currentFrame[1, 0] := true
currentFrame[1, 1] := true
currentFrame[1, 2] := true

for _ in 1..3 {
  def frame := nextFrame
  computeNextLife(currentFrame, frame)
  nextFrame := currentFrame
  currentFrame := frame
  println(currentFrame)
}


a = 3
if( a == 1 ){
    io.writeln( 'a == 1' )
}else if( a== 3 ){
    io.writeln( 'a == 3' )
}else{
    io.writeln( 'a is neither 1 nor 3' )
}


n = 70
n += 1
subr init
  for r = 1 to n - 1
    for c = 1 to n - 1
      i = r * n + c
      if randomf < 0.3
        f[i] = 1
      .
    .
  .
.
f = 100 / (n - 1)
subr show
  clear
  for r = 1 to n - 1
    for c = 1 to n - 1
      if f[r * n + c] = 1
        move (c - 1) * f (r - 1) * f
        rect f * 0.9 f * 0.9
      .
    .
  .
.
subr update
  swap f[] p[]
  for r = 1 to n - 1
    sm = 0
    i = r * n
    sr = p[i - n + 1] + p[i + 1] + p[i + n + 1]
    for c = 1 to n - 1
      i += 1
      sl = sm
      sm = sr
      sr = p[i - n + 1] + p[i + 1] + p[i + n + 1]
      s = sl + sm + sr
      if s = 3 or s = 4 and p[i] = 1
        f[i] = 1
      else
        f[i] = 0
      .
    .
  .
.
on timer
  call update
  call show
  timer 0.2
.
on mouse_down
  c = mouse_x div f
  r = mouse_y div f
  i = r * n + c + n + 1
  f[i] = 1 - f[i]
  call show
  timer 3
.
len f[] n * n + n + 1
len p[] n * n + n + 1
call init
timer 0


if (input.Field == "Hello World") {
    sVar = "good";
} else if (input.Field == "Bye World") {
    sVar = "bad";
} else {
    sVar = "neutral";
}


import "ecere"

define seed = 12345;
define popInit = 1000;
define width = 100;
define height = 100;
define cellWidth = 4;
define cellHeight = 4;

Array<byte> grid { size = width * height };
Array<byte> newState { size = width * height };

class GameOfLife : Window
{
   caption = $"Conway's Game of Life";
   background = lightBlue;
   borderStyle = sizable;
   hasMaximize = true;
   hasMinimize = true;
   hasClose = true;
   clientSize = { width * cellWidth, height * cellHeight };

   Timer tickTimer
   {
      delay = 0.05, started = true, userData = this;

      bool DelayExpired()
      {
         int y, x, ix = 0;
         for(y = 0; y < height; y++)
         {
            for(x = 0; x < width; x++, ix++)
            {
               int nCount = 0;
               byte alive;
               if(x > 0       && y > 0        && grid[ix - width - 1]) nCount++;
               if(               y > 0        && grid[ix - width    ]) nCount++;
               if(x < width-1 && y > 0        && grid[ix - width + 1]) nCount++;
               if(x > 0                       && grid[ix         - 1]) nCount++;
               if(x < width - 1               && grid[ix         + 1]) nCount++;
               if(x > 0       && y < height-1 && grid[ix + width - 1]) nCount++;
               if(               y < height-1 && grid[ix + width    ]) nCount++;
               if(x < width-1 && y < height-1 && grid[ix + width + 1]) nCount++;

               if(grid[ix])
                  alive = nCount >= 2 && nCount <= 3; // Death
               else
                  alive = nCount == 3; // Birth
               newState[ix] = alive;
            }
         }
         memcpy(grid.array, newState.array, width * height);
         Update(null);
         return true;
      }
   };

   void OnRedraw(Surface surface)
   {
      int x, y;
      int ix = 0;

      surface.background = navy;
      for(y = 0; y < height; y++)
      {
         for(x = 0; x < width; x++, ix++)
         {
            if(grid[ix])
            {
               int sy = y * cellHeight;
               int sx = x * cellWidth;
               surface.Area(sx, sy, sx + cellWidth-1, sy + cellHeight-1);
            }
         }
      }
   }

   bool OnCreate()
   {
      int i;

      RandomSeed(seed);

      for(i = 0; i < popInit; i++)
      {
         int x = GetRandom(0, width-1);
         int y = GetRandom(0, height-1);

         grid[y * width + x] = 1;
      }
      return true;
   }
}

GameOfLife life {};


if (condition)
    // Do thing, DM uses indentation for control flow.

if (condition)
    // Do thing

else if (condition)
    // Do thing

else
    // Do thing


if(a == b)
{
    add()
}
else if(a == c)
    less() //{}'s optional for one-liners
else
{
    both()
}


import "prelude.eg"
import "io.ego"

using System
using List
using IO

def boardsize = 5

def empty = [ X Y -> 0 ]

def insert =
    [ X Y BOARD ->
        [ X0 Y0 -> if and (X0 == X) (Y0 == Y) then 1
                    else BOARD X0 Y0 ] ]

def coords =
    let R = fromto 0 (boardsize - 1) in
        [ XX YY -> map (\X -> map (\Y -> X Y) YY) XX ] R R

def printcell =
    [ 0 -> print ". "
    | _ -> print "* " ]

def printboard =
    [ BOARD ->
        let M  = map [XX -> let _ = map [(X Y) -> printcell (BOARD X Y)] XX in print "\n" ] coords in
            nop ]

def count =
    [ BOARD, X, Y ->
        (BOARD (X - 1) (Y - 1)) + (BOARD (X) (Y - 1)) + (BOARD (X+1) (Y - 1)) +
        (BOARD (X - 1) Y) + (BOARD (X+1) Y) +
        (BOARD (X - 1) (Y+1)) + (BOARD (X) (Y+1)) + (BOARD (X+1) (Y+1)) ]

def next =
    [ 0 N -> if N == 3 then 1 else 0
    | _ N -> if or (N == 2) (N == 3) then 1 else 0 ]

def updateboard =
    [ BOARD ->
        let XX = map (\(X Y) -> X Y (BOARD X Y) (count BOARD X Y)) (flatten coords) in
        let YY = map (\(X Y C N) -> X Y (next C N)) XX in
            foldr [(X Y 0) BOARD -> BOARD | (X Y _) BOARD -> insert X Y BOARD ] empty YY ]

def blinker =
    (insert 1 2) @ (insert 2 2) @ (insert 3 2)

def main =
    let GEN0 = blinker empty in
    let GEN1 = updateboard GEN0 in
    let GEN2 = updateboard GEN1 in
    let _ = map [ G -> let _ = print "generation:\n" in printboard G ] {GEN0, GEN1, GEN2} in
        nop


if a:
    pass
elseif b:
    pass
else: # c, maybe?
    pass


import extensions;
import system'threading;
import cellular;

const int maxX = 48;
const int maxY = 28;

const int DELAY = 50;

sealed class Model
{
    Space   theSpace;
    RuleSet theRuleSet;
    bool    started;

    event Func<Space, object> OnUpdate;

    constructor newRandomset(RuleSet transformSet)
    {
        theSpace := new IntMatrixSpace.allocate(maxY, maxX, randomSet);

        theRuleSet := transformSet;

        started := false
    }

    constructor newLoaded(RuleSet initSet, RuleSet transformSet)
    {
        theSpace := IntMatrixSpace.allocate(maxY, maxX, initSet);

        theRuleSet := transformSet;

        started := false
    }

    private onUpdate()
    {
        OnUpdate.?(theSpace)
    }

    run()
    {
        if (started)
        {
            theSpace.update(theRuleSet)
        }
        else
        {
            started := true
        };

        self.onUpdate()
    }
}

singleton gameOfLifeRuleSet : RuleSet
{
    proceed(Space s, int x, int y, ref int retVal)
    {
        int cell := s.at(x, y);
        int number := s.LiveCell(x, y, 1); // NOTE : number of living cells around the self includes the cell itself

        if (cell == 0 && number == 3)
        {
            retVal := 1
        }
        else if (cell == 1 && (number == 4 || number == 3))
        {
            retVal := 1
        }
        else
        {
            retVal := 0
        }
    }
}

public extension presenterOp : Space
{
    print()
    {
        console.setCursorPosition(0, 0);

        int columns := self.Columns;
        int rows := self.Rows;

        for(int i := 0, i < rows, i += 1)
        {
            for(int j := 0, j < columns, j += 1)
            {
                int cell := self.at(i, j);

                console.write((cell == 0).iif(" ","o"));
            };

            console.writeLine()
        }
    }
}

public program()
{
    auto model := Model.newRandomset(gameOfLifeRuleSet);
    console.clear();

    model.OnUpdate := (Space sp){ sp.print() };

    until (console.KeyAvailable)
    {
        model.run();

        threadControl.sleep:DELAY
    };

    console.readChar()
}


if (okay) {
    println("okay")
} else if (!okay) {
    println("not okay")
} else {
    println("not my day")
}


defmodule Conway do
  def game_of_life(name, size, generations, initial_life\\nil) do
    board = seed(size, initial_life)
    print_board(board, name, size, 0)
    reason = generate(name, size, generations, board, 1)
    case reason do
      :all_dead -> "no more life."
      :static   -> "no movement"
      _         -> "specified lifetime ended"
    end
    |> IO.puts
    IO.puts ""
  end

  defp new_board(n) do
    for x <- 1..n, y <- 1..n, into: %{}, do: {{x,y}, 0}
  end

  defp seed(n, points) do
    if points do
      points
    else # randomly seed board
      (for x <- 1..n, y <- 1..n, do: {x,y}) |> Enum.take_random(10)
    end
    |> Enum.reduce(new_board(n), fn pos,acc -> %{acc | pos => 1} end)
  end

  defp generate(_, _, generations, _, gen) when generations < gen, do: :ok
  defp generate(name, size, generations, board, gen) do
    new = evolve(board, size)
    print_board(new, name, size, gen)
    cond do
      barren?(new) -> :all_dead
      board == new -> :static
      true         -> generate(name, size, generations, new, gen+1)
    end
  end

  defp evolve(board, n) do
    for x <- 1..n, y <- 1..n, into: %{}, do: {{x,y}, fate(board, x, y, n)}
  end

  defp fate(board, x, y, n) do
    irange = max(1, x-1) .. min(x+1, n)
    jrange = max(1, y-1) .. min(y+1, n)
    sum = ((for i <- irange, j <- jrange, do: board[{i,j}]) |> Enum.sum) - board[{x,y}]
    cond do
      sum == 3                       -> 1
      sum == 2 and board[{x,y}] == 1 -> 1
      true                           -> 0
    end
  end

  defp barren?(board) do
    Enum.all?(board, fn {_,v} -> v == 0 end)
  end

  defp print_board(board, name, n, generation) do
    IO.puts "#{name}: generation #{generation}"
    Enum.each(1..n, fn y ->
      Enum.map(1..n, fn x -> if board[{x,y}]==1, do: "#", else: "." end)
      |> IO.puts
    end)
  end
end

Conway.game_of_life("blinker", 3, 2, [{2,1},{2,2},{2,3}])
Conway.game_of_life("glider", 4, 4, [{2,1},{3,2},{1,3},{2,3},{3,3}])
Conway.game_of_life("random", 5, 10)


i = random 10
if i mod 2 = 0
  print i & " is divisible by 2"
elif i mod 3 = 0
  print i & " is divisible by 3"
else
  print i & " is not divisible by 2 or 3"
.


show_if_with_parenthesis = fn (Num) {
    if (Num == 1) {
        io.format("is one~n")
    }
    else if (Num === 2) {
        io.format("is two~n")
    }
    else {
        io.format("not one not two~n")
    }
}

show_if_without_parenthesis = fn (Num) {
    if Num == 1 {
        io.format("is one~n")
    }
    else if Num === 2 {
        io.format("is two~n")
    }
    else {
        io.format("not one not two~n")
    }
}

show_switch_with_parenthesis = fn (Num) {
    switch (Num) {
        case (1) {
            io.format("one!~n")
        }
        case (2) {
            io.format("two!~n")
        }
        else {
            io.format("else~n")
        }
    }
}

show_switch_without_parenthesis = fn (Num) {
    switch (Num) {
        case 1 {
            io.format("one!~n")
        }
        case 2 {
            io.format("two!~n")
        }
        else {
            io.format("else~n")
        }
    }
}

@public
run = fn () {
    show_if_with_parenthesis(random.uniform(3))
    show_if_without_parenthesis(random.uniform(3))

    show_switch_with_parenthesis(random.uniform(3))
    show_switch_without_parenthesis(random.uniform(3))
}


#!/usr/bin/env emacs -script
;; -*- lexical-binding: t -*-
;; run: ./conways-life conways-life.config
(require 'cl-lib)

(defconst blinker '("***"))
(defconst toad '(".***" "***."))
(defconst pentomino-p '(".**" ".**" ".*."))
(defconst pi-heptomino '("***" "*.*" "*.*"))
(defconst glider '(".*." "..*" "***"))
(defconst pre-pulsar '("***...***" "*.*...*.*" "***...***"))
(defconst ship '("**." "*.*" ".**"))
(defconst pentadecathalon '("**********"))
(defconst clock '("..*." "*.*." ".*.*" ".*.."))

(defmacro swap (a b)
  `(setq ,b (prog1 ,a (setq ,a ,b))))

(cl-defstruct world rows cols data)

(defun new-world (rows cols)
  (make-world :rows rows :cols cols :data (make-vector (* rows cols) nil)))

(defmacro world-pt (w r c)
  `(+ (* (mod ,r (world-rows ,w)) (world-cols ,w))
      (mod ,c (world-cols ,w))))

(defmacro world-ref (w r c)
  `(aref (world-data ,w) (world-pt ,w ,r ,c)))

(defun print-world (world)
  (dotimes (r (world-rows world))
    (dotimes (c (world-cols world))
      (princ (format "%c" (if (world-ref world r c) ?* ?.))))
    (terpri)))

(defun insert-pattern (world row col shape)
  (let ((r row)
        (c col))
    (unless (listp shape)
      (setq shape (symbol-value shape)))
    (dolist (row-data shape)
      (dolist (col-data (mapcar 'identity row-data))
        (setf (world-ref world r c) (not (or (eq col-data ?.))))
        (setq c (1+ c)))
      (setq r (1+ r))
      (setq c col))))

(defun neighbors (world row col)
  (let ((n 0))
    (dolist (offset '((1 . 1) (1 . 0) (1 . -1) (0 . 1) (0 . -1) (-1 . 1) (-1 . 0) (-1 . -1)))
      (when (world-ref world (+ row (car offset)) (+ col (cdr offset)))
        (setq n (1+ n))))
    n))

(defun advance-generation (old new)
  (dotimes (r (world-rows old))
    (dotimes (c (world-cols old))
      (let ((n (neighbors old r c)))
        (setf (world-ref new r c)
              (if (world-ref old r c)
                  (or (= n 2) (= n 3))
                (= n 3)))))))

(defun read-config (file-name)
  (with-temp-buffer
    (insert-file-contents-literally file-name)
    (read (current-buffer))))

(defun get-config (key config)
  (let ((val (assoc key config)))
    (if (null val)
        (error (format "missing value for %s" key))
      (cdr val))))

(defun insert-patterns (world patterns)
  (dolist (p patterns)
    (apply 'insert-pattern (cons world p))))

(defun simulate-life (file-name)
  (let* ((config (read-config file-name))
         (rows (get-config 'rows config))
         (cols (get-config 'cols config))
         (generations (get-config 'generations config))
         (a (new-world rows cols))
         (b (new-world rows cols)))
    (insert-patterns a (get-config 'patterns config))
    (dotimes (g generations)
      (princ (format "generation %d\n" g))
      (print-world a)
      (advance-generation a b)
      (swap a b))))

(simulate-life (elt command-line-args-left 0))