Licence CC BY

La compilation « Just In Time » : un exemple et des conséquences

Juste à temps ! Quand ce qui devrait aller plus vite, va moins vite.

Dernière mise à jour :
Auteur :
Catégorie :
Temps de lecture estimé : 4 heures et 15 minutes

Peut-être un jour, alors que vous utilisiez un interpréteur pour votre langage préféré1 avez-vous entendu parler de « Compilation à la volée », de « traduction dynamique » ou plus probablement de « Just In Time compilation », parfois abrégé en « JIT ».

Voici venir une aventure qui m’est arrivée, et par laquelle nous allons voir ce qu’est ce concept de « compilation dynamique » plus en détail, et surtout de ce que ça peut impliquer comme comportements bizarroïdes et contre-intuitifs à l’exécution d’un code.


  1. Ça implique que ce langage soit normalement interprété et non compilé en code machine. On peut citer les langages à JVM (Java, Kotlin, Groovy, Scala…), les langages de la famille .NET (C#, VB.net, etc.), certaines implémentations de Python (PyPy a la compilation JIT mais pas CPython, l’implémentation de référence), et dans plein d’autres cas.

Quelques concepts pour commencer

Je vais commencer par définir brièvement trois concepts nécessaires à la bonne compréhension de cet article. Comme le but n’est absolument pas de les détailler, il y aura des raccourcis et j’invite le lecteur curieux à se documenter par lui-même.

Une machine virtuelle et son bytecode

Une machine virtuelle (ou Virtual Machine en anglais, ce qui donne le très courant VM) désigne, comme son nom le laisse penser, un ordinateur émulé par un autre ordinateur. On en distingue en gros deux catégories :

  1. Les machines virtuelles génériques qui émulent à peu près le matériel que l’on trouve dans votre ordinateur ou dans un serveur. Elles permettent de faire tourner un système « normal ». Ça a des tas d’applications que l’on va totalement ignorer aujourd’hui.
  2. Les machines virtuelles spécifiques qui émulent une architecture qui n’existe généralement pas sous forme physique. C’est elles qui vont nous intéresser aujourd’hui.

Pourquoi ces machines virtuelles existent, si les puces (processeurs, organisation mémoire, etc) qu’elles émulent n’existent pas physiquement ? Principalement pour des raisons de compatibilité.

La logique est la suivante : un ordinateur, ça peut avoir des tas d’architectures différentes. Si on veut faire un programme compilé multi-plateforme, il faut le compiler pour chaque architecture. Et le re-compiler si l’une d’elles évolue ou apparaît. C’est lourd.

On pourrait imaginer interpréter directement le code source, donc lire la source et l’exécuter au fur et à mesure, mais c’est généralement catastrophique en terme de performances.

Une solution classique, c’est de compiler le code source pour une machine qui n’existe pas physiquement, et le résultat de cette compilation va être interprété par une machine virtuelle avec des performances bien meilleures que si on essayer d’interpréter directement le code source. Le produit de la compilation pour la machine virtuelle s’appelle bytecode.

Les principaux avantages sont :

  • Le programme est compilé une seule fois et est directement utilisable partout où la machine virtuelle est disponible1.
  • Si une architecture physique apparaît ou évolue, il « suffit » de compiler la machine virtuelle sur cette architecture pour que tous les programmes soient directement utilisables.
  • On peut dimensionner la machine virtuelle comme on veut dans les limites de la machine physique, par exemple pour éviter de trop consommer.

Les principaux inconvénients sont :

  • La machine virtuelle ajoute une couche de complexité qui peut provoquer des comportements étonnants si on est pas au fait de ses subtilités. L’un d’entre eux est l’objet de cet article.2
  • Comme le code est interprété, il s’exécutera moins vite qu’un programme compilé. Ceci n’est pas forcément un problème, c’est une question de priorités.

Je rajoute que cette compilation en bytecode peut être commandée par le développeur (comme en Java et dans les langages à JVM – les fichiers .class), ou automatiquement à la lecture des fichiers source par l’interpréteur (comme en Python – les fichiers .pyc).

Brainfuck

Brainfuck est un langage de programmation ésotérique, qui s’écrit avec seulement huit symboles et qui malgré tout est Turing-complet, c’est-à-dire qu’on peut théoriquement écrire n’importe quel programme avec.

Mais ce n’est pas ses caractéristiques exotiques qui vont nous intéresser aujourd’hui, mais une propriété annexe du langage. En effet, Brainfuck peut aussi être vu comme une définition de machine virtuelle ultra-simple :

  • processeur à huit instructions, dont
  • une instruction d’entrée, et
  • une instruction de sortie,
  • deux zones mémoires (une pour le programme, une pour la mémoire de travail).

Et c’est tout.

Il peut donc peut être interprété directement ou être compilé en autre chose – c’est même un excellent point de départ pour apprendre ce genre de technique. Il y a d’ailleurs un atelier sur Zeste de Savoir à propos des interpréteurs et des compilateurs Brainfuck.

C’est cette simplicité à l’interpréter ou à le compiler qui va nous servir pour le présent sujet.

La JVM et Kotlin

Les exemples qui suivent sont écrits en langage Kotlin, qui permet d’écrire des programmes qui tournent sur la machine virtuelle Java tout en étant moins verbeux que Java.

Normalement le langage est relativement clair ; dans tous les cas il n’est nul besoin de comprendre les subtilités de l’implémentation pour suivre cet article, les grandes lignes suffisent.


  1. En théorie seulement. En pratique, si le langage le permet et si le programme utilise des portions de code spécifiques à un système d’exploitation ou à une architecture, le programme ne sera plus utilisable partout.

  2.  Et pour la petite histoire, c’est l’une des raisons de la mauvaise réputation de la machine virtuelle Java.

Pour aller plus vite, compilons du Brainfuck !

Ainsi donc, comme Brainfuck peut être vu comme une machine virtuelle, nous pouvons écrire un interpréteur. Et comme souvent en informatique, on veut que cet interpréteur aille vite.

Un interpréteur optimisé de Brainfuck

Comme Brainfuck est un langage simple, lui créer un interpréteur est simple aussi, de même que son optimisation. Je laisse ceux que les détails intéressent lire ce billet, mais après un peu de travail on obtient cet interpréteur :

package fr.spacefox.brainfuck

import java.io.File
import java.io.IOException
import java.io.InputStreamReader
import kotlin.system.measureTimeMillis

class CompiledBrainFuck(strProgram: String) {

    private val instructions = strProgram
            .filter { it in listOf('+', '-', '>', '<', '[', ']', '.', ',') }
            .replace(">[-]<[->+<]", "m")    // Move
            .replace("[->+<]",      "a")    // Addition
            .replace("[-]",         "0")    // Cell reset
            .toCharArray()
    private val ram = IntArray(30000)
    private val inputReader = InputStreamReader(System.`in`)

    fun run() {
        val (compiled, parameters) = compile(instructions)
        var ramPtr = 0
        var programPtr = 0

        do {
            when (compiled[programPtr]) {
                '>', '<'    -> ramPtr += parameters[programPtr]
                '+', '-'    -> ram[ramPtr] = (ram[ramPtr] + parameters[programPtr]) % 0xFFFF
                '0'         -> ram[ramPtr] = 0
                'a'         -> { ram[ramPtr + 1] += ram[ramPtr] ; ram[ramPtr] = 0 }
                'm'         -> { ram[ramPtr + 1] = ram[ramPtr] ; ram[ramPtr] = 0 }
                '['         -> if (ram[ramPtr] == 0) programPtr = parameters[programPtr]
                ']'         -> if (ram[ramPtr] != 0) programPtr = parameters[programPtr]
                '.'         -> print(ram[ramPtr].toChar())
                ','         -> ram[ramPtr] = try { inputReader.read() } catch (e: IOException) { 0 }
            }
            programPtr++
        } while (programPtr < compiled.size)
    }

    private fun compile(unCompiled: CharArray): Pair<CharArray, IntArray> {

        val compiled = mutableListOf<Char>()
        val parameters = mutableListOf<Int>()
        var lastInstruction = '\u0000'

        for (instruction in unCompiled) {
            when (instruction) {
                '>', '+' -> if (instruction == lastInstruction) {
                                parameters[parameters.lastIndex]++
                            } else {
                                compiled.add(instruction)
                                parameters.add(1)
                            }
                '<', '-' -> if (instruction == lastInstruction) {
                                parameters[parameters.lastIndex]--
                            } else {
                                compiled.add(instruction)
                                parameters.add(-1)
                            }
                else -> {
                    compiled.add(instruction)
                    parameters.add(0)
                }
            }
            lastInstruction = instruction
        }

        for (open in 0..compiled.lastIndex) {
            if (compiled[open] == '[') {
                var loops = 1
                var close = open
                while (loops > 0) {
                    close++
                    when {
                        compiled[close] == '[' -> loops++
                        compiled[close] == ']' -> loops--
                    }
                }
                parameters[open] = close    // Match [ → ]
                parameters[close] = open    // Match ] → [
            }
        }

        return Pair(compiled.toCharArray(), parameters.toIntArray())
    }
}

fun main(args: Array<String>) {
    val time = measureTimeMillis { CompiledBrainFuck(File(args[0]).readText()).run() }
    println("Completed in $time ms")
}

C’est bien un interpréteur, même si on y voit une étape de « compilation » interne : à chaque fois qu’on va exécuter un programme, on va lire tout le code source, le transformer et l’exécuter, et ce même si on l’a déjà exécuté juste avant.

Par rapport à un interpréteur naïf, on trouve les modifications suivantes :

  1. Ajout de 3 instructions au langage (parce qu’on sait que certaines séries d’instructions Brainfuck peuvent se simplifier) ;
  2. Regroupement des instructions « empilables » (exemple : 5 instructions « +1 » de suite → 1 instruction « +5 ») ;
  3. Suppression des commentaires, sauts de lignes, etc – tout ce qui est inutile.

Testons avec un programme qui calcule et affiche une fractale :

AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDEGFFEEEEDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAAAABBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDEEEFGIIGFFEEEDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAABBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDEEEEFFFI KHGGGHGEDDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAABBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEFFGHIMTKLZOGFEEDDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAABBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEEFGGHHIKPPKIHGFFEEEDDDDDDDDDCCCCCCCCCCBBBBBBBBBBBBBBBBBB
AAAAAAAAAABBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEEFFGHIJKS  X KHHGFEEEEEDDDDDDDDDCCCCCCCCCCBBBBBBBBBBBBBBBB
AAAAAAAAABBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEEFFGQPUVOTY   ZQL[MHFEEEEEEEDDDDDDDCCCCCCCCCCCBBBBBBBBBBBBBB
AAAAAAAABBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEFFFFFGGHJLZ         UKHGFFEEEEEEEEDDDDDCCCCCCCCCCCCBBBBBBBBBBBB
AAAAAAABBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEFFFFFFGGGGHIKP           KHHGGFFFFEEEEEEDDDDDCCCCCCCCCCCBBBBBBBBBBB
AAAAAAABBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDEEEEEFGGHIIHHHHHIIIJKMR        VMKJIHHHGFFFFFFGSGEDDDDCCCCCCCCCCCCBBBBBBBBB
AAAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDEEEEEEFFGHK   MKJIJO  N R  X      YUSR PLV LHHHGGHIOJGFEDDDCCCCCCCCCCCCBBBBBBBB
AAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDEEEEEEEEEFFFFGH O    TN S                       NKJKR LLQMNHEEDDDCCCCCCCCCCCCBBBBBBB
AAAAABBCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDEEEEEEEEEEEEFFFFFGHHIN                                 Q     UMWGEEEDDDCCCCCCCCCCCCBBBBBB
AAAABBCCCCCCCCCCCCCCCCCCCCCCCCCDDDDEEEEEEEEEEEEEEEFFFFFFGHIJKLOT                                     [JGFFEEEDDCCCCCCCCCCCCCBBBBB
AAAABCCCCCCCCCCCCCCCCCCCCCCDDDDEEEEEEEEEEEEEEEEFFFFFFGGHYV RQU                                     QMJHGGFEEEDDDCCCCCCCCCCCCCBBBB
AAABCCCCCCCCCCCCCCCCCDDDDDDDEEFJIHFFFFFFFFFFFFFFGGGGGGHIJN                                            JHHGFEEDDDDCCCCCCCCCCCCCBBB
AAABCCCCCCCCCCCDDDDDDDDDDEEEEFFHLKHHGGGGHHMJHGGGGGGHHHIKRR                                           UQ L HFEDDDDCCCCCCCCCCCCCCBB
AABCCCCCCCCDDDDDDDDDDDEEEEEEFFFHKQMRKNJIJLVS JJKIIIIIIJLR                                               YNHFEDDDDDCCCCCCCCCCCCCBB
AABCCCCCDDDDDDDDDDDDEEEEEEEFFGGHIJKOU  O O   PR LLJJJKL                                                OIHFFEDDDDDCCCCCCCCCCCCCCB
AACCCDDDDDDDDDDDDDEEEEEEEEEFGGGHIJMR              RMLMN                                                 NTFEEDDDDDDCCCCCCCCCCCCCB
AACCDDDDDDDDDDDDEEEEEEEEEFGGGHHKONSZ                QPR                                                NJGFEEDDDDDDCCCCCCCCCCCCCC
ABCDDDDDDDDDDDEEEEEFFFFFGIPJIIJKMQ                   VX                                                 HFFEEDDDDDDCCCCCCCCCCCCCC
ACDDDDDDDDDDEFFFFFFFGGGGHIKZOOPPS                                                                      HGFEEEDDDDDDCCCCCCCCCCCCCC
ADEEEEFFFGHIGGGGGGHHHHIJJLNY                                                                        TJHGFFEEEDDDDDDDCCCCCCCCCCCCC
A                                                                                                 PLJHGGFFEEEDDDDDDDCCCCCCCCCCCCC
ADEEEEFFFGHIGGGGGGHHHHIJJLNY                                                                        TJHGFFEEEDDDDDDDCCCCCCCCCCCCC
ACDDDDDDDDDDEFFFFFFFGGGGHIKZOOPPS                                                                      HGFEEEDDDDDDCCCCCCCCCCCCCC
ABCDDDDDDDDDDDEEEEEFFFFFGIPJIIJKMQ                   VX                                                 HFFEEDDDDDDCCCCCCCCCCCCCC
AACCDDDDDDDDDDDDEEEEEEEEEFGGGHHKONSZ                QPR                                                NJGFEEDDDDDDCCCCCCCCCCCCCC
AACCCDDDDDDDDDDDDDEEEEEEEEEFGGGHIJMR              RMLMN                                                 NTFEEDDDDDDCCCCCCCCCCCCCB
AABCCCCCDDDDDDDDDDDDEEEEEEEFFGGHIJKOU  O O   PR LLJJJKL                                                OIHFFEDDDDDCCCCCCCCCCCCCCB
AABCCCCCCCCDDDDDDDDDDDEEEEEEFFFHKQMRKNJIJLVS JJKIIIIIIJLR                                               YNHFEDDDDDCCCCCCCCCCCCCBB
AAABCCCCCCCCCCCDDDDDDDDDDEEEEFFHLKHHGGGGHHMJHGGGGGGHHHIKRR                                           UQ L HFEDDDDCCCCCCCCCCCCCCBB
AAABCCCCCCCCCCCCCCCCCDDDDDDDEEFJIHFFFFFFFFFFFFFFGGGGGGHIJN                                            JHHGFEEDDDDCCCCCCCCCCCCCBBB
AAAABCCCCCCCCCCCCCCCCCCCCCCDDDDEEEEEEEEEEEEEEEEFFFFFFGGHYV RQU                                     QMJHGGFEEEDDDCCCCCCCCCCCCCBBBB
AAAABBCCCCCCCCCCCCCCCCCCCCCCCCCDDDDEEEEEEEEEEEEEEEFFFFFFGHIJKLOT                                     [JGFFEEEDDCCCCCCCCCCCCCBBBBB
AAAAABBCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDEEEEEEEEEEEEFFFFFGHHIN                                 Q     UMWGEEEDDDCCCCCCCCCCCCBBBBBB
AAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDEEEEEEEEEFFFFGH O    TN S                       NKJKR LLQMNHEEDDDCCCCCCCCCCCCBBBBBBB
AAAAAABBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDEEEEEEFFGHK   MKJIJO  N R  X      YUSR PLV LHHHGGHIOJGFEDDDCCCCCCCCCCCCBBBBBBBB
AAAAAAABBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDEEEEEFGGHIIHHHHHIIIJKMR        VMKJIHHHGFFFFFFGSGEDDDDCCCCCCCCCCCCBBBBBBBBB
AAAAAAABBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEFFFFFFGGGGHIKP           KHHGGFFFFEEEEEEDDDDDCCCCCCCCCCCBBBBBBBBBBB
AAAAAAAABBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEFFFFFGGHJLZ         UKHGFFEEEEEEEEDDDDDCCCCCCCCCCCCBBBBBBBBBBBB
AAAAAAAAABBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEEFFGQPUVOTY   ZQL[MHFEEEEEEEDDDDDDDCCCCCCCCCCCBBBBBBBBBBBBBB
AAAAAAAAAABBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDDEEEEEEFFGHIJKS  X KHHGFEEEEEDDDDDDDDDCCCCCCCCCCBBBBBBBBBBBBBBBB
AAAAAAAAAAABBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEEFGGHHIKPPKIHGFFEEEDDDDDDDDDCCCCCCCCCCBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAABBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDDDEEEEEFFGHIMTKLZOGFEEDDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAABBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDDDEEEEFFFI KHGGGHGEDDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBB
AAAAAAAAAAAAAAABBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCDDDDDDDDDDEEEFGIIGFFEEEDDDDDDDDCCCCCCCCCBBBBBBBBBBBBBBBBBBBBBBBBBB
Completed in 10323 ms

En ajoutant un bête compteur dans la boucle d’interprétation principale (lignes 17 à 29), on se rends compte que le calcul de cette fractale, une fois le code optimisé, nécessite l’exécution de 2 951 274 897 instructions, soit 285 893 141 instructions par seconde.

Un compilateur optimisé de Brainfuck

Ça peut paraître gigantesque, mais pour des instructions aussi simples que celle-ci, votre processeur physique peut probablement en exécuter au moins une par cycle d’horloge, soit plusieurs milliards par seconde.

Or, en inspectant la boucle principale du programme, on se rends compte que pour chaque instruction, le programme doit en plus :

  • récupérer l’instruction dans le tableau,
  • déterminer l’instruction à exécuter à partir de son code,
  • et incrémenter le pointeur d’instruction.

Alors chacune de ces actions a probablement un temps d’exécution ridiculement court ; mais elles doivent être effectuées jusqu’à plusieurs milliards de fois pour terminer le programme. Donc autant dire que si on pouvait s’en passer, ça nous permettrait probablement de gagner pas mal de performances.

L’adaptation du programme précédent pour lui faire générer un programme Kotlin à partir des sources Brainfuck n’est pas bien compliqué. La principale différence est qu’il n’y a plus besoin de calculer quoi que ce soit pour la correspondance des sauts, puisque le saut [ est l’équivalent d’un while et que le saut ] est l’équivalent de l'} de ce while. Ce qui nous donne :

package fr.spacefox.brainfuck

import java.io.File

class CompilerBrainFuck(strProgram: String) {

    private val instructions = strProgram
            .filter { it in listOf('+', '-', '>', '<', '[', ']', '.', ',') }
            .replace(">[-]<[->+<]", "m")    // Move
            .replace("[->+<]",      "a")    // Addition
            .replace("[-]",         "0")    // Cell reset
            .toCharArray()

    fun run() {
        val (compiled, parameters) = compile(instructions)

        println("import java.io.InputStreamReader")
        println("fun main(args: Array<String>) {")
        println("val start = System.currentTimeMillis()")
        println("val ram = IntArray(30000)")
        println("val inputReader = InputStreamReader(System.`in`)")
        println("var ramPtr = 0")

        for ((i, c) in compiled.withIndex()) {
            when (c) {
                '>', '<'    -> println("ramPtr += ${parameters[i]}")
                '+', '-'    -> println("ram[ramPtr] = (ram[ramPtr] + ${parameters[i]}) % 0xFFFF")
                '0'         -> println("ram[ramPtr] = 0")
                'a'         -> println("ram[ramPtr + 1] += ram[ramPtr] ; ram[ramPtr] = 0")
                'm'         -> println("ram[ramPtr + 1] = ram[ramPtr] ; ram[ramPtr] = 0")
                '['         -> println("while (ram[ramPtr] != 0) {")
                ']'         -> println("}")
                '.'         -> println("print(ram[ramPtr].toChar())")
                ','         -> println("ram[ramPtr] = try { inputReader.read() } catch (e: IOException) { 0 }")
            }
        }
        println("println(\"Completed in ${'$'}{ System.currentTimeMillis() - start} ms\")")
        println("}")
    }

    private fun compile(unCompiled: CharArray): Pair<CharArray, IntArray> {

        val compiled = mutableListOf<Char>()
        val parameters = mutableListOf<Int>()
        var lastInstruction = '\u0000'

        for (instruction in unCompiled) {
            when (instruction) {
                '>', '+' -> if (instruction == lastInstruction) {
                                parameters[parameters.lastIndex]++
                            } else {
                                compiled.add(instruction)
                                parameters.add(1)
                            }
                '<', '-' -> if (instruction == lastInstruction) {
                                parameters[parameters.lastIndex]--
                            } else {
                                compiled.add(instruction)
                                parameters.add(-1)
                            }
                else -> {
                    compiled.add(instruction)
                    parameters.add(0)
                }
            }
            lastInstruction = instruction
        }

        return Pair(compiled.toCharArray(), parameters.toIntArray())
    }
}

fun main(args: Array<String>) {
    CompilerBrainFuck(File(args[0]).readText()).run()
}

Ces soixante-quinze lignes de programme appliquées au programme de génération de fractale nous donnent pas moins de trois-mille-huit-cent-six (3 806) lignes de programme Kotlin, que voici après formatage (en secret, pour que ça reste « lisible ») :

import java.io.InputStreamReader

fun main(args: Array<String>) {
    val start = System.currentTimeMillis()
    val ram = IntArray(30000)
    val inputReader = InputStreamReader(System.`in`)
    var ramPtr = 0
    ram[ramPtr] = (ram[ramPtr] + 13) % 0xFFFF
    while (ram[ramPtr] != 0) {
        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
        ramPtr += 1
        ram[ramPtr] = (ram[ramPtr] + 2) % 0xFFFF
        ramPtr += 3
        ram[ramPtr] = (ram[ramPtr] + 5) % 0xFFFF
        ramPtr += 1
        ram[ramPtr] = (ram[ramPtr] + 2) % 0xFFFF
        ramPtr += 1
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        ramPtr += -6
    }
    ramPtr += 5
    ram[ramPtr] = (ram[ramPtr] + 6) % 0xFFFF
    ramPtr += 1
    ram[ramPtr] = (ram[ramPtr] + -3) % 0xFFFF
    ramPtr += 10
    ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
    while (ram[ramPtr] != 0) {
        while (ram[ramPtr] != 0) {
            ramPtr += 9
        }
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        while (ram[ramPtr] != 0) {
            ramPtr += -9
        }
        ramPtr += 9
        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
    }
    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
    while (ram[ramPtr] != 0) {
        ramPtr += 8
        ram[ramPtr] = 0
        ramPtr += 1
    }
    ramPtr += -9
    while (ram[ramPtr] != 0) {
        ramPtr += -9
    }
    ramPtr += 8
    ram[ramPtr] = 0
    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
    ramPtr += -7
    ram[ramPtr] = (ram[ramPtr] + 5) % 0xFFFF
    while (ram[ramPtr] != 0) {
        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += 9
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += -9
        }
        ramPtr += 9
    }
    ramPtr += 7
    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
    ramPtr += 27
    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
    ramPtr += -17
    while (ram[ramPtr] != 0) {
        ramPtr += -9
    }
    ramPtr += 3
    ram[ramPtr] = 0
    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
    while (ram[ramPtr] != 0) {
        ramPtr += 6
        while (ram[ramPtr] != 0) {
            ramPtr += 7
            ram[ramPtr] = 0
            ramPtr += 2
        }
        ramPtr += -9
        while (ram[ramPtr] != 0) {
            ramPtr += -9
        }
        ramPtr += 7
        ram[ramPtr] = 0
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        ramPtr += -6
        ram[ramPtr] = (ram[ramPtr] + 4) % 0xFFFF
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -9
            }
            ramPtr += 9
        }
        ramPtr += 6
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        ramPtr += -6
        ram[ramPtr] = (ram[ramPtr] + 7) % 0xFFFF
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -9
            }
            ramPtr += 9
        }
        ramPtr += 6
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        ramPtr += -16
        while (ram[ramPtr] != 0) {
            ramPtr += -9
        }
        ramPtr += 3
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = 0
            ramPtr += 6
            while (ram[ramPtr] != 0) {
                ramPtr += 7
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -6
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 6
                }
                ramPtr += -6
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 6
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -2
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -3
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -1
                }
                ramPtr += 8
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 8
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -7
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 7
                }
                ramPtr += -7
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 7
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -2
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -3
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -2
                }
                ramPtr += 8
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -7
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 7
            }
            ramPtr += -7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 7
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -2
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -5
            }
            ramPtr += 9
            ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
            while (ram[ramPtr] != 0) {
                while (ram[ramPtr] != 0) {
                    ramPtr += 9
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            }
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 8
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                }
                ramPtr += -4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -2
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 2
                        }
                        ramPtr += -2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 2
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -4
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 9
                    }
                    ramPtr += -8
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 9
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += -10
                }
                ramPtr += 1
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 8
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ramPtr += -1
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                    }
                    ramPtr += -1
                    ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                    ramPtr += 4
                }
                ramPtr += -3
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 3
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -3
                }
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -9
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 8
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 5
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -5
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 5
                }
                ramPtr += -5
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 3
                        }
                        ramPtr += -3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -4
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 9
                    }
                    ramPtr += -8
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 9
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += -11
                }
                ramPtr += 2
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += -2
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 8
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ramPtr += -1
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                    }
                    ramPtr += -1
                    ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                    ramPtr += 4
                }
                ramPtr += -3
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 3
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -3
                }
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -9
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -36
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 36
                }
                ramPtr += 5
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 9
            ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
            while (ram[ramPtr] != 0) {
                while (ram[ramPtr] != 0) {
                    ramPtr += 9
                }
                ramPtr += -9
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            }
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += 21
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += -3
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 3
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -3
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 3
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -3
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 3
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -13
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                        ramPtr += 4
                        ram[ramPtr] = 0
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                        while (ram[ramPtr] != 0) {
                            ramPtr += 9
                        }
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 3
                    }
                    ramPtr += -3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -12
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                        ramPtr += 3
                        ram[ramPtr] = 0
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                        while (ram[ramPtr] != 0) {
                            ramPtr += 9
                        }
                        ramPtr += 1
                        ram[ramPtr] = 0
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 1
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -1
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -8
                }
                ramPtr += 8
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += -7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 3
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -4
            }
            ramPtr += 9
            ram[ramPtr] = (ram[ramPtr] + 26) % 0xFFFF
            ramPtr += 2
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -4
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 4
            }
            ramPtr += -4
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 4
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -2
                ram[ramPtr] = 0
                ramPtr += -2
            }
            ramPtr += 2
            while (ram[ramPtr] != 0) {
                ramPtr += -7
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -1
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -2
                    ram[ramPtr] = 0
                }
                ramPtr += 1
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                    }
                    ramPtr += 3
                }
                ramPtr += 13
                while (ram[ramPtr] != 0) {
                    ramPtr += 2
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 5
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 3
                ram[ramPtr] = 0
                ramPtr += 6
                while (ram[ramPtr] != 0) {
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 9
                    }
                    ramPtr += 7
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                    }
                    ramPtr += -5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -6
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 2
                            }
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 1
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -3
                            }
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 9
                        }
                        ramPtr += -8
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                    }
                    ramPtr += 9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 9
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -9
                        }
                        ramPtr += -10
                    }
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -7
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 7
                        }
                        ramPtr += -1
                        ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                        ramPtr += 3
                    }
                    ramPtr += -2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 2
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                    }
                    ramPtr += -5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                    }
                    ramPtr += -5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -6
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 2
                            }
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -4
                            }
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 9
                        }
                        ramPtr += -8
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                    }
                    ramPtr += 9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 9
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -9
                        }
                        ramPtr += -10
                    }
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -6
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 6
                        }
                        ramPtr += -1
                        ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                        ramPtr += 4
                    }
                    ramPtr += -3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -36
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 36
                    }
                    ramPtr += 5
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -36
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 36
                    }
                    ramPtr += 6
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ramPtr += 8
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -7
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 7
                    }
                    ramPtr += -7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 7
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 6
                    ram[ramPtr] = 0
                    ramPtr += 3
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 4
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 1
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 5
                }
                ramPtr += 1
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                        ram[ramPtr] = (ram[ramPtr] + 2) % 0xFFFF
                        ramPtr += -4
                    }
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                }
                ramPtr += -1
                ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                ramPtr += -5
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -5
                }
                ramPtr += 6
                ram[ramPtr] = 0
                ramPtr += -6
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ramPtr += 2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -2
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 3
                            }
                            ramPtr += -3
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -12
                                while (ram[ramPtr] != 0) {
                                    ramPtr += -9
                                }
                                ramPtr += 3
                                ram[ramPtr] = 0
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 6
                                while (ram[ramPtr] != 0) {
                                    ramPtr += 9
                                }
                                ramPtr += 1
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -1
                            }
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -3
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 2
                            }
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -11
                                while (ram[ramPtr] != 0) {
                                    ramPtr += -9
                                }
                                ramPtr += 4
                                ram[ramPtr] = 0
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 5
                                while (ram[ramPtr] != 0) {
                                    ramPtr += 9
                                }
                                ramPtr += 1
                                ram[ramPtr] = 0
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -1
                            }
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -1
                            while (ram[ramPtr] != 0) {
                                ramPtr += 9
                            }
                            ramPtr += -8
                        }
                        ramPtr += 8
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                        while (ram[ramPtr] != 0) {
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                            }
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -2
                            }
                            ramPtr += 8
                        }
                        ramPtr += -8
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 5
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -4
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 4
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -14
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 11
                                    while (ram[ramPtr] != 0) {
                                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                        ramPtr += 3
                                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                        ramPtr += -3
                                    }
                                    ramPtr += -1
                                }
                                ramPtr += 1
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 3
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -14
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 11
                                }
                                ramPtr += -2
                            }
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 4
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -3
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 3
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -14
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 11
                                }
                                ramPtr += -1
                            }
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -3
                            }
                            ramPtr += -12
                        }
                        ramPtr += 4
                        ram[ramPtr] = 0
                        ramPtr += -4
                    }
                    ramPtr += 3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 3
                    }
                    ramPtr += -3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                        while (ram[ramPtr] != 0) {
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -1
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 1
                            }
                            ramPtr += -1
                            ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                            ramPtr += 8
                        }
                        ramPtr += -8
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 5
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -3
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 3
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -14
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 10
                                    while (ram[ramPtr] != 0) {
                                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                        ramPtr += 4
                                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                        ramPtr += -4
                                    }
                                    ramPtr += 1
                                }
                                ramPtr += -1
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 4
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -14
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 10
                                }
                                ramPtr += -1
                            }
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -4
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 4
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -14
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 10
                                }
                                ramPtr += 1
                            }
                            ramPtr += -1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 4
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -4
                            }
                            ramPtr += -11
                        }
                        ramPtr += 6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -6
                    }
                }
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                }
                ramPtr += -4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 5
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -4
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 4
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -14
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 3
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += -3
                                }
                                ramPtr += -1
                            }
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -14
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                            }
                            ramPtr += -2
                        }
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 4
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -3
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -14
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                            }
                            ramPtr += -1
                        }
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -3
                        }
                        ramPtr += -12
                    }
                }
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 2
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 5
                while (ram[ramPtr] != 0) {
                    ramPtr += 2
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 6
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -5
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 2
                            }
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 1
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -3
                            }
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 9
                        }
                        ramPtr += -8
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                    }
                    ramPtr += 9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 9
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -9
                        }
                        ramPtr += -10
                    }
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -7
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 7
                        }
                        ramPtr += -1
                        ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                        ramPtr += 3
                    }
                    ramPtr += -2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 2
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -36
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 36
                    }
                    ramPtr += 6
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 5
                ram[ramPtr] = 0
                ramPtr += 4
                ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ramPtr += 3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -4
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 4
                        }
                        ramPtr += -4
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 4
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -13
                            while (ram[ramPtr] != 0) {
                                ramPtr += -9
                            }
                            ramPtr += 4
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 5
                            while (ram[ramPtr] != 0) {
                                ramPtr += 9
                            }
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -1
                        }
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 3
                        }
                        ramPtr += -3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -12
                            while (ram[ramPtr] != 0) {
                                ramPtr += -9
                            }
                            ramPtr += 3
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 6
                            while (ram[ramPtr] != 0) {
                                ramPtr += 9
                            }
                            ramPtr += 1
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -1
                        }
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ramPtr += 9
                        }
                        ramPtr += -8
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 3
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -3
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 3
                }
                ramPtr += -3
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 3
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 6
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -3
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                        }
                        ramPtr += -3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -3
                        }
                        ramPtr += 8
                    }
                    ramPtr += -8
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -1
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -1
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -10
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 12
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -2
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 2
                                }
                                ramPtr += -1
                            }
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -10
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 12
                            }
                            ramPtr += -3
                        }
                        ramPtr += 2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -10
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 12
                            }
                            ramPtr += -1
                        }
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -2
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 2
                        }
                        ramPtr += -13
                    }
                }
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                }
                ramPtr += -4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -2
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                        }
                        ramPtr += -2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -2
                        }
                        ramPtr += 8
                    }
                    ramPtr += -8
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -1
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -10
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -1
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 1
                                }
                                ramPtr += 1
                            }
                            ramPtr += -1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -1
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -10
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                            }
                            ramPtr += -2
                        }
                        ramPtr += 3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -2
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -1
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -10
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                            }
                            ramPtr += 1
                        }
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 1
                        }
                        ramPtr += -12
                    }
                    ramPtr += 5
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -5
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 3
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 4
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 3
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 5
                while (ram[ramPtr] != 0) {
                    ramPtr += 7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                    }
                    ramPtr += -6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 4
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 1
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 5
                }
                ramPtr += 2
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                        ram[ramPtr] = (ram[ramPtr] + 2) % 0xFFFF
                        ramPtr += -4
                    }
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 2
                }
                ramPtr += -2
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 2
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -2
                }
                ramPtr += -5
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -5
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ramPtr += 3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -3
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 2
                            }
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -11
                                while (ram[ramPtr] != 0) {
                                    ramPtr += -9
                                }
                                ramPtr += 4
                                ram[ramPtr] = 0
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 5
                                while (ram[ramPtr] != 0) {
                                    ramPtr += 9
                                }
                                ramPtr += 1
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -1
                            }
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -2
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 3
                            }
                            ramPtr += -3
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -12
                                while (ram[ramPtr] != 0) {
                                    ramPtr += -9
                                }
                                ramPtr += 3
                                ram[ramPtr] = 0
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 6
                                while (ram[ramPtr] != 0) {
                                    ramPtr += 9
                                }
                                ramPtr += 1
                                ram[ramPtr] = 0
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -1
                            }
                        }
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -1
                            while (ram[ramPtr] != 0) {
                                ramPtr += 9
                            }
                            ramPtr += -8
                        }
                        ramPtr += 8
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 3
                    }
                    ramPtr += -3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                        while (ram[ramPtr] != 0) {
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -1
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 1
                            }
                            ramPtr += -1
                            ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                            ramPtr += 8
                        }
                        ramPtr += -8
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 4
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -2
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 2
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -13
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 10
                                    while (ram[ramPtr] != 0) {
                                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                        ramPtr += 3
                                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                        ramPtr += -3
                                    }
                                    ramPtr += 1
                                }
                                ramPtr += -1
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 3
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -13
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 10
                                }
                                ramPtr += -1
                            }
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -3
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 3
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -13
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 10
                                }
                                ramPtr += 1
                            }
                            ramPtr += -1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -3
                            }
                            ramPtr += -11
                        }
                        ramPtr += 5
                        ram[ramPtr] = 0
                        ramPtr += 2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -7
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 7
                        }
                        ramPtr += -7
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 7
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -2
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -5
                        }
                    }
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                        while (ram[ramPtr] != 0) {
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                            }
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -2
                            }
                            ramPtr += 8
                        }
                        ramPtr += -8
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 4
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -3
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 3
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -13
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 11
                                    while (ram[ramPtr] != 0) {
                                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                        ramPtr += 2
                                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                        ramPtr += -2
                                    }
                                    ramPtr += -1
                                }
                                ramPtr += 1
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 2
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -13
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 11
                                }
                                ramPtr += -2
                            }
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -2
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 2
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += -13
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += 11
                                }
                                ramPtr += -1
                            }
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -2
                            }
                            ramPtr += -12
                        }
                    }
                    ramPtr += 4
                    ram[ramPtr] = 0
                    ramPtr += -4
                }
                ramPtr += 4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                }
                ramPtr += -4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -7
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 7
                    }
                    ramPtr += -7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 7
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -5
                    }
                    ramPtr += 9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 4
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -3
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -13
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                                while (ram[ramPtr] != 0) {
                                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                    ramPtr += 2
                                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                    ramPtr += -2
                                }
                                ramPtr += -1
                            }
                            ramPtr += 1
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -13
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                            }
                            ramPtr += -2
                        }
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -13
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 11
                            }
                            ramPtr += -1
                        }
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -2
                        }
                        ramPtr += -12
                    }
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 2
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 6
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 3
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 5
                while (ram[ramPtr] != 0) {
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                    }
                    ramPtr += -5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -5
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 2
                            }
                            ramPtr += -2
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 2
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -4
                            }
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 9
                        }
                        ramPtr += -8
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                    }
                    ramPtr += 9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 9
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -9
                        }
                        ramPtr += -10
                    }
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -6
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 6
                        }
                        ramPtr += -1
                        ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                        ramPtr += 4
                    }
                    ramPtr += -3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                    }
                    ramPtr += -5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -6
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += -3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 3
                            }
                            ramPtr += -3
                            while (ram[ramPtr] != 0) {
                                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                                ramPtr += 3
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += 1
                                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                                ramPtr += -4
                            }
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 9
                        }
                        ramPtr += -8
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                    }
                    ramPtr += 9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += 2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 9
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -9
                        }
                        ramPtr += -11
                    }
                    ramPtr += 2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += -2
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -6
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 6
                        }
                        ramPtr += -1
                        ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                        ramPtr += 4
                    }
                    ramPtr += -3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -3
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -36
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 36
                    }
                    ramPtr += 5
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + 15) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -9
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 21
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -3
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -3
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -3
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 3
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -4
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 4
                        }
                        ramPtr += -4
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 4
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -13
                            while (ram[ramPtr] != 0) {
                                ramPtr += -9
                            }
                            ramPtr += 4
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 5
                            while (ram[ramPtr] != 0) {
                                ramPtr += 9
                            }
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -1
                        }
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 3
                        }
                        ramPtr += -3
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -12
                            while (ram[ramPtr] != 0) {
                                ramPtr += -9
                            }
                            ramPtr += 3
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 6
                            while (ram[ramPtr] != 0) {
                                ramPtr += 9
                            }
                            ramPtr += 1
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -1
                        }
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ramPtr += 9
                        }
                        ramPtr += -8
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 2
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 2
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                }
                ramPtr += -4
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 4
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -2
                    ram[ramPtr] = 0
                    ramPtr += -2
                }
                ramPtr += 2
            }
            ramPtr += -2
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += 4
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -4
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 4
            }
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += -4
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 4
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -6
                print(ram[ramPtr].toChar())
                ramPtr += 2
            }
            ramPtr += 4
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -7
                print(ram[ramPtr].toChar())
                ramPtr += 7
            }
            ramPtr += -3
            ram[ramPtr] = 0
            ramPtr += 1
            ram[ramPtr] = 0
            ramPtr += 1
            ram[ramPtr] = 0
            ramPtr += 1
            ram[ramPtr] = 0
            ramPtr += 1
            ram[ramPtr] = 0
            ramPtr += 1
            ram[ramPtr] = 0
            ramPtr += 3
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += 3
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 5
                ram[ramPtr] = 0
                ramPtr += 4
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 1
            ram[ramPtr] = (ram[ramPtr] + 11) % 0xFFFF
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 9
            }
            ramPtr += 4
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += 9
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += -14
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -7
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 7
            }
            ramPtr += -7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 7
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ram[ramPtr] = 0
                ramPtr += 2
                while (ram[ramPtr] != 0) {
                    ramPtr += 9
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                    }
                    ramPtr += -6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -7
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                        ramPtr += 7
                        ram[ramPtr] = 0
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 3
                    }
                    ramPtr += -10
                }
            }
            ramPtr += 7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -7
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 7
            }
            ramPtr += -7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 7
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 2
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -4
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                    }
                    ramPtr += -4
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 4
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -4
                    }
                    ramPtr += 8
                }
                ramPtr += -2
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -7
                while (ram[ramPtr] != 0) {
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 2
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                    }
                    ramPtr += -14
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 9
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -7
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 3
                        }
                        ramPtr += -1
                        ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                        ramPtr += 7
                    }
                    ramPtr += -6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -6
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 7
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -4
                ram[ramPtr] = 0
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -3
            }
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += 7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -7
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 7
            }
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += -7
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 7
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 2
                while (ram[ramPtr] != 0) {
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 2
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -2
                    }
                    ramPtr += 4
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += 1
                    ram[ramPtr] = 0
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -7
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 1
                        while (ram[ramPtr] != 0) {
                            ramPtr += -1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -3
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 3
                        }
                        ramPtr += -1
                        ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                        ramPtr += 7
                    }
                    ramPtr += -6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -6
                    }
                    ramPtr += -1
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 1
                ram[ramPtr] = (ram[ramPtr] + 5) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += 9
                }
                ramPtr += 4
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -5
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 9
                while (ram[ramPtr] != 0) {
                    ramPtr += 5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -5
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -5
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 5
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -7
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 7
                        }
                        ramPtr += -7
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 7
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -16
                            while (ram[ramPtr] != 0) {
                                ramPtr += -9
                            }
                            ramPtr += 4
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 5
                            while (ram[ramPtr] != 0) {
                                ramPtr += 9
                            }
                            ramPtr += 1
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -1
                        }
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -7
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 7
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -7
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 7
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -2
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += -5
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 5
                        }
                        ramPtr += -5
                        while (ram[ramPtr] != 0) {
                            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                            ramPtr += 5
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -14
                            while (ram[ramPtr] != 0) {
                                ramPtr += -9
                            }
                            ramPtr += 3
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += 6
                            while (ram[ramPtr] != 0) {
                                ramPtr += 9
                            }
                            ramPtr += 1
                            ram[ramPtr] = 0
                            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                            ramPtr += -1
                        }
                    }
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -1
                        while (ram[ramPtr] != 0) {
                            ramPtr += 9
                        }
                        ramPtr += -8
                    }
                    ramPtr += 8
                }
                ramPtr += -9
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
                ramPtr += 4
                ram[ramPtr] = 0
                ramPtr += -3
                ram[ramPtr] = (ram[ramPtr] + 5) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 9
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -9
                    }
                    ramPtr += 9
                }
                ramPtr += 4
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += -5
                while (ram[ramPtr] != 0) {
                    ramPtr += -9
                }
            }
            ramPtr += 3
        }
        ramPtr += -4
        print(ram[ramPtr].toChar())
        ramPtr += 10
        while (ram[ramPtr] != 0) {
            ramPtr += 6
            ram[ramPtr] = 0
            ramPtr += 3
        }
        ramPtr += -9
        while (ram[ramPtr] != 0) {
            ramPtr += -9
        }
        ramPtr += 1
        ram[ramPtr] = (ram[ramPtr] + 10) % 0xFFFF
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 9
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -9
            }
            ramPtr += 9
        }
        ramPtr += 5
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        ramPtr += 9
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        ramPtr += -15
        while (ram[ramPtr] != 0) {
            ramPtr += -9
        }
        ramPtr += 8
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += -8
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += 8
        }
        ramPtr += -8
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += 8
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ram[ramPtr] = 0
            ramPtr += 1
            while (ram[ramPtr] != 0) {
                ramPtr += 9
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += 8
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -7
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 7
                }
                ramPtr += -7
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 7
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -8
                    while (ram[ramPtr] != 0) {
                        ramPtr += -9
                    }
                    ramPtr += 8
                    ram[ramPtr] = 0
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 2
                }
                ramPtr += -10
            }
        }
        ramPtr += 8
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += -8
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += 8
        }
        ramPtr += -8
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += 8
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += 1
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 5
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -5
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                }
                ramPtr += -5
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 5
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -5
                }
                ramPtr += 8
            }
            ramPtr += -1
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += -8
            while (ram[ramPtr] != 0) {
                ramPtr += 6
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 2
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -2
                }
                ramPtr += -15
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 9
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 8
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -8
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ramPtr += -1
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -2
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 2
                    }
                    ramPtr += -1
                    ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                    ramPtr += 8
                }
                ramPtr += -7
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 7
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -7
                }
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -9
            }
            ramPtr += 8
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += -5
            ram[ramPtr] = 0
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += -3
        }
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        ramPtr += 8
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += -8
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += 8
        }
        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
        ramPtr += -8
        while (ram[ramPtr] != 0) {
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += 8
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += 1
            while (ram[ramPtr] != 0) {
                ramPtr += 6
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 2
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -2
                }
                ramPtr += 3
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += 1
                ram[ramPtr] = 0
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                ramPtr += 8
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -8
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += 1
                    while (ram[ramPtr] != 0) {
                        ramPtr += -1
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -2
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 2
                    }
                    ramPtr += -1
                    ram[ramPtr + 1] += ram[ramPtr]; ram[ramPtr] = 0
                    ramPtr += 8
                }
                ramPtr += -7
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 7
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -7
                }
                ramPtr += -1
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -9
            }
            ramPtr += 1
            ram[ramPtr] = (ram[ramPtr] + 5) % 0xFFFF
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 9
            }
            ramPtr += 5
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += 27
            ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
            ramPtr += -6
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 9
            while (ram[ramPtr] != 0) {
                ramPtr += 6
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -6
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 6
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -6
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 6
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -8
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 8
                    }
                    ramPtr += -8
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 8
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -17
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                        ramPtr += 4
                        ram[ramPtr] = 0
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 5
                        while (ram[ramPtr] != 0) {
                            ramPtr += 9
                        }
                        ramPtr += 1
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 8
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -8
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 8
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += -8
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 8
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -2
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += -6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                    }
                    ramPtr += -6
                    while (ram[ramPtr] != 0) {
                        ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                        ramPtr += 6
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -15
                        while (ram[ramPtr] != 0) {
                            ramPtr += -9
                        }
                        ramPtr += 3
                        ram[ramPtr] = 0
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += 6
                        while (ram[ramPtr] != 0) {
                            ramPtr += 9
                        }
                        ramPtr += 1
                        ram[ramPtr] = 0
                        ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                        ramPtr += -1
                    }
                }
                ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                ramPtr += 1
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += -1
                    while (ram[ramPtr] != 0) {
                        ramPtr += 9
                    }
                    ramPtr += -8
                }
                ramPtr += 8
            }
            ramPtr += -9
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
            ramPtr += 4
            ram[ramPtr] = 0
            ramPtr += -3
            ram[ramPtr] = (ram[ramPtr] + 5) % 0xFFFF
            while (ram[ramPtr] != 0) {
                ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                while (ram[ramPtr] != 0) {
                    ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
                    ramPtr += 9
                    ram[ramPtr] = (ram[ramPtr] + 1) % 0xFFFF
                    ramPtr += -9
                }
                ramPtr += 9
            }
            ramPtr += 5
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += 27
            ram[ramPtr] = (ram[ramPtr] + -1) % 0xFFFF
            ramPtr += -6
            while (ram[ramPtr] != 0) {
                ramPtr += -9
            }
        }
        ramPtr += 3
    }
    println("Completed in ${System.currentTimeMillis() - start} ms")
}

Bon d’accord, c’est gros et illisible, mais on s’en fiche : c’est un programme généré non destiné à être maintenu ni même lu. Et vu qu’on ne fait plus d’opération « inutile » (modulo les limitations de Brainfuck), ça devrait dépoter !

C’est l’heure du test !

Pour rappel, notre interpréteur exécutait en 2 951 274 897 instructions en 10 323 millisecondes, soit 285 893 141 instructions par seconde. Là, on supprime trois opérations à effectuer pour chacune de ces instructions, soit pas loin de six milliards d’opérations. On devrait donc pouvoir diviser au moins le temps d’exécution par deux, non ?

Et pourtant :

$ java  CompiledKt
[… affichage de la fractale …]
Completed in 25647 ms

Process finished with exit code 0

Soit environ deux fois et demie le temps d’exécution de la version interprétée. Alors qu’on s’attendait à peu près au résultat inverse ! Et le résultat est reproductible ! Mais comment est-ce possible ?

Comment expliquer ces résultats ?

Éliminons l’hypothèse d’un défaut de la JVM

Il se pourrait que ce soit un défaut de la JVM. C’est difficile d’expliquer en quoi, mais cette idée vient assez rapidement, d’autant plus quand on ne maitrise pas les arcanes du langage.

La JVM utilisée est celle-ci, mais les résultats sont comparables avec Java 11 :

$ java -version
java version "1.8.0_111"
Java(TM) SE Runtime Environment (build 1.8.0_111-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.111-b14, mixed mode)

HotSpot est le petit nom de la JVM commune à OpenJDK et à la version de Java distribuée par Oracle. Il va donc falloir chercher ailleurs.

Par exemple, chez IBM, qui produit une JVM qui s’appelle J9 et qui maintenant a été libérée et donnée à la fondation Eclipse. Qu’est-ce qu’elle nous donne ?

JRE (Java 8) Interpréteur Programme compilé
OpenJDK 11 secondes 25,5 secondes
Oracle 11 secondes 27 secondes
IBM/OpenJ9 11 secondes 42 secondes

Dans tous les cas les temps d’exécution sont précis à ± 10 %, ne serait-ce que parce que l’ordinateur fait autre chose et que la fréquence du CPU n’est pas fixe.

Ah. Zut. Non seulement le phénomène est reproduit, mais en plus l’écart entre la version interprétée et la version compilée est pire avec la JVM IBM. Donc, c’est un comportement « normal » indépendant du fabriquant de notre JVM, apparemment.

Quand la machine virtuelle se permet des optimisations…

Depuis le début de cet article, je parle de « compilation Just In Time », c’est donc probablement l’explication à ce mystère, non ? Eh bien oui.

Si on consulte la documentation Oracle, on voit que la JVM peut automatiquement « convertir le code Java en code machine hautement optimisé ».

Le fonctionnement « standard » d’une compilation « Just In Time » est le suivant :

  • Le programme est exécuté par l’interpréteur (rapide à démarrer) et est surveillé.
  • Si un bout de code est souvent exécuté, il est compilé en langage machine et optimisé.

Ceci permet des performances optimales dans le cas général, puisque seules les portions de code critiques sont optimisées, on ne perds pas de temps à tout compiler à la volée.

Or, pour que le compilateur intégré à la machine virtuelle se mette en route, il faut que la portion de code puisse être identifiée comme critique pour les performances. Et donc qu’elle soit exécutée plusieurs fois.

C’est précisément là l’explication du pourquoi notre Brainfuck compilé en Kotlin est plus lent que sa version interprétée :

  • Le code Kotlin produit par la compilation est une énorme méthode de près de 4000 lignes : la machine virtuelle a du mal à déterminer quelles sont les portions critiques et donc ne compile presque rien en langage machine.
  • Le code de l’interpréteur, au contraire, est très court et contient une boucle exécutée littéralement des milliards de fois ; la JVM comprends donc très rapidement que cette portion de code est à optimiser autant que possible.

En résumé :

La compilation « Just In Time » est une fonctionnalité puissante et généralement efficace des machines virtuelles, mais qui peut complexifier l’optimisation et produire des comportements imprévus dans les cas aux limites.

Des mesures de cette compilation « Just In Time »

Pour vérifier l’impact de cette compilation – et la véracité de tout ce que je vous dit depuis le début de cet article –, on va essayer de mesurer l’impact de cette fonctionnalité. Pour ça, on va jouer avec deux options que l’on peut passer à la JVM :

  1. -Xint permet de forcer la JVM en mode « Interpréteur seulement » et donc de désactiver totalement ce genre d’optimisation.
  2. -Xjit:count=0 est une option spécifique à la JVM IBM qui permet de forcer la compilation en langage machine de tout le programme avant son exécution. L’équivalent OpenJDK/Oracle est -Xcomp mais ne semble pas fonctionner.

JRE

(Java 8)

Interpréteur

Programme compilé

Standard

Sans JIT

Compilation forcée

Standard

Sans JIT

Compilation forcée

OpenJDK

11 s

113 s

N/A

25,5 s

24 s

N/A

Oracle

11 s

118 s

N/A

27 s

28 s

N/A

IBM/OpenJ9

11 s

193(!) s

5 + 12,5 s

41 s

41 s

5 + 3,8 s

Le premier chiffre dans les colonnes « Compilation forcée » correspond au temps de lancement de la JVM, donc de compilation. Ce temps est négligeable sur des programmes aussi petits dans tous les autres cas.

On remarque donc que :

  • Comme supposé, dans le cas du programme Brainfuck compilé en Kotlin, le compilateur « Just In Time » ne se lance pas et donc n’optimise rien1.
  • Quelle que soit la JVM, quand le compilateur « Just In Time » s’enclenche, il est très efficace2.
  • L’interpréteur Oracle/OpenJDK est beaucoup plus performant que celui d’IBM.
  • Forcer la compilation sur la JVM IBM ralentit beaucoup le démarrage, pour un gain de temps final qui n’est pas garanti.

Ce qui nous permet donc cet avertissement :

Ne touchez pas aux options de réglage du compilateur JIT, à moins de savoir exactement ce que vous faites ! 


  1.  Le fait que le programme généré à partir du programme BrainFuck soit plus rapide en désactivant le JIT avec OpenJDK semble reproductible chez moi. Ça peut être un artefact de mesure comme quelque chose de réel, par exemple le temps gagné en ne tentant pas de détecter les bouts de code à optimiser. Répondre à cette question nécessiterait des tests poussés hors sujet de cet article.

  2. Or ce compilateur JIT n’existait pas avant Java 1.2, sorti en 1998. Ceci peut être l’une des explications à la réputation de lenteur de Java.


La compilation à la volée, dite « Just In Time » est un mécanisme qui permet à une machine virtuelle d’optimiser les performances en compilant des parties du programme au lieu de les interpréter.

Cette fonctionnalité permet d’améliorer beaucoup les performances, mais peut provoquer des effets surprenants dans des cas particuliers. Les réglages automatiques de cette fonctionnalité sont normalement efficaces, quand il est possible d’y toucher manuellement, mieux vaut avoir des métriques précises pour éviter les mauvaises surprises.


Merci à @d3m0t3p, @lthms et @artragis pour leurs commentaires pendant la bêta.

2 commentaires

J’ai commencé le C# cette année et ce billet est un plaisir à lire ! On entend souvent parler de Compilation à la volée sans vraiment connaitre les détails ^^' Merci beaucoup pour cette vulgarisation de haute qualité. :)

( Les stats sont très intéressante pour réaliser la puissance de cette fonctionnalité, les personnes qui ont du codé ceci sont des monstres ! o_O )

+0 -0
Vous devez être connecté pour pouvoir poster un message.
Connexion

Pas encore inscrit ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte