I had the occasion to meet a variety of people with different attitudes to problems and different backgrounds, this last thing was really interesting for me since I think that in the last months I’ve lived inside a bubble made of exclusively Haskellers.

Some Nixers on the summit of a nearby volcano

Personally I’ve decided to devote most of my time on Nix internals since it’s something that could help with the creation of new “2nix” tools (in the last months I had many headaches due to tools like haskell.nix and their extensive use of IFDs). My colleague Márton and me also had a call with John Ericson which let to this PR.

I’ve also spent a day digging into Hydra trying to make it show the evaluation log during the evaluation itself and not only after that the evaluation terminated. In the end I wasn’t able to make it work (it was more difficult than I initially thought) but it was an useful experience and perhaps in the future I’ll continue these efforts.

Other people worked on different projects like making secure boot work on NixOS, on nixifing a live coding environment, on this really interesting project about making shell snippets in markdown testable, on nil (a really powerful LSP server for Nix written in Rust) or also noogle, a Hoogle like engine for Nix.

The keyboard is a Lily58, a “6*4+4keys column-staggered split keyboard”, I only found the normal version, not “Pro”. Since a split keyboard wasn’t enough I’ve also decided to use blank caps. The reason behind this choice was that I was not sure about the layout when I ordered the parts, and since it was a long time that I wanted to learn to blind type I thought it would have been convenient. I have to partially change my mind, I spent some days using sites like keybr to improve my skills but as soon I need more unusual symbols (not the characters in short) I’ve difficulties.

The keyboard on my desk

Then, when in September I needed to type efficiently and I abondoned this keyboard. In conclusion, in hindsight, it would have been better to choose a less exotic keyboard, I would had more satisfaction.

Parts

I found out that trying to get the parts as European citzen is not easy, there’s little choice an the prices are high. I didn’t find any Italian resellers for this kind of stuff.

However in the end I ordered the needed parts from - MechBoards for the PCB, the diodes, the buttons, the TRRS cable (and connectors) and the acrylic case. - this store on AliExpress for the switches, the keycaps and the Pro Micros.

Usually I don’t like to advertise for free, but this time I’m happy to do it because the both the stores were really kind. The first one resent me a piece I accidentaly broke and the second one let me personalize my order with the two central 1.5U grey keys.

The total cost was about 120 euros, shipping included. However I’ve some leftovers, some caps and switches, I could build a useless numpad.

Case, cable, buttons and connectors

The case is in acrylic and it’s transparent, had a protection film that made me really satisfied when I removed it.

Acrylic case from MechBoard

With the case I also got the TRSS cable and two females connectors.

TRSS cable, female connectors and buttons

Obviously with the case there were also the needed screws and some rubber pads, however in the end I used other pads I already had because they were higher.

Screws

The PCBs and the diodes

The two PCBs are identicals and they work differently depending on the side you sold components on, an ingenious and cost-effective design.

Lily58, black is cool

The other side

A lot of diodes

Diodes

Microcontrollers

Two Arduino Pro Micro are needed, I got them on AliExpress because they were cheaper. One of them gave me problems, after I soldered it I realized the flashing didn’t work.

The Pro Micro pinout

I’m a noob and this was a good lesson, next time I’ll flash both the microcontrollers before soldering them, however I don’t know if the Pro Micro was already broken or I damaged it during the soldering.

Display

The Lily58 supports two SSD1306 displays, since I broke one of them one of them is useless because it only shows a static logo I used only one.

The SSD1306

Considering the negligible cost (about 1 dollar from AliExpress) I think I’ll reuse this display in future projects.

Switches and caps

For this keyboard it’s important to pay attention to profile of the keycaps because of the exotic layout. My choice fell on blank keycaps with the XDA profile (all the caps are the same) so this wasn’t a problem.

The SSD1306

For the switches I chose the blue MX Gateron, I alredy tried them and I really liked the clicky feedback. Moreover they were quite cheap on AliExpress.

A sleepy watchdog

My trusty watchdog oversaw and certified the entire procedure.

A good boy

Assembling

I followed this guide, even if I don’t speak japanese I was able to understand thanks to the numerous images.

The schematic

The soldering was quite easy, I thought it would be more difficult, maybe the merit is of the PCB of excellent build quality.

Soldering the diodes

The matrix of diodes

Software

The official firmware uses QMK, since I consider useless the standard display usage (showing che current keyboard layer (a QMK thing to associate different keys to the same switch) and the latest typed characters) I forked it to add support for custom text messages using the HID protocol.

Flashing the firmware

Then I created a simple utility to that sends messages to the keyboard, the idea was to integrate this utility with Emacs to show things like:

• the minibuffer
• the kill ring
• generic information about the system, like the temperature or the CPU/Memory/Disk/Network usage
• currently playing music (I use Mopidy so it’s easy with Emacs)

At the end I was able to to show a message from Emacs but I never implemented all the rest.

Final result

Front

Back

That’s all for now.

Le liste sono testo

Questa è una lista non ordinata…

• Un elemento
• Un altro elemento
• Un altro ancora

…mentre questa qui è ordinata (e anche innestata).

1. Primo
2. Secondo
   • Prima parte
   • Seconda parte
3. Terzo
4. Quarto

TODO ciao

DONE mondo

DONE finito

Inserire link è facile, si può anche omettere il nome: https://google.it.

Anche cambiare paragrafo è semplice, passiamo ora alle note e agli avvertimenti.

Note: Questa è una nota, che bella…

Warning: Stai attento, questo non è un avvertimento!

Ed ecco una citazione.

Considerate la vostra semenza: fatti non foste a viver come bruti, ma per seguir virtute e canoscenza

È possibile mantere la formattazione in questo modo.

Considerate la vostra semenza:
fatti non foste a viver come bruti,
ma per seguir virtute e canoscenza

Sorgenti

Si possono includere sorgenti senza evidenziazione della sintassi.

+------+.      +------+       +------+       +------+      .+------+
|`.    | `.    |\     |\      |      |      /|     /|    .' |    .'|
|  `+--+---+   | +----+-+     +------+     +-+----+ |   +---+--+'  |
|   |  |   |   | |    | |     |      |     | |    | |   |   |  |   |
+---+--+.  |   +-+----+ |     +------+     | +----+-+   |  .+--+---+
 `. |    `.|    \|     \|     |      |     |/     |/    |.'    | .'
   `+------+     +------+     +------+     +------+     +------+'

Altrimenti anche codice specifico di linguaggi di programmazione, con l’opzione per visualizzare il numero di riga.

(define fail
  (lambda ()
    (error "Amb tree exhausted")))

(define-syntax amb
  (syntax-rules ()
    ((AMB) (FAIL))                      ; Two shortcuts.
    ((AMB expression) expression)

    ((AMB expression ...)
     (LET ((FAIL-SAVE FAIL))
       ((CALL-WITH-CURRENT-CONTINUATION ; Capture a continuation to
	  (LAMBDA (K-SUCCESS)           ;   which we return possibles.
	    (CALL-WITH-CURRENT-CONTINUATION
	      (LAMBDA (K-FAILURE)       ; K-FAILURE will try the next
		(SET! FAIL K-FAILURE)   ;   possible expression.
		(K-SUCCESS              ; Note that the expression is
		 (LAMBDA ()             ;   evaluated in tail position
		   expression))))       ;   with respect to AMB.
	    ...
	    (SET! FAIL FAIL-SAVE)       ; Finally, if this is reached,
	    FAIL-SAVE)))))))            ;   we restore the saved FAIL.

Tabelle

Si possono inserire tabelle, con allineamenti differenti colonna per colonna e una meravigliosa idascalia.

Ma che bella questa tabella

Immagini

Includere immagini è semplice (didascalia opzionale):

Bel paesaggio

Video

Ecco l’eversione della sfera¹, ovvero come risvoltarla.

{video:sphere-eversion.mp4}

Matematica

Si può scrivere matematica inline, per esempio lo sapevi che \(\nexists a,b,c \in \mathbb{N}\) tali che

\[a^n+^n=c^n \forall n\]

dove \(n \in \mathbb{N}\).

Definition: Ciao

Theorem: If an integer \(n\) is greater than 2, then the equation \(a^n + b^n = c^n\) has no solutions in non-zero integers \(a\), \(b\), and \(c\).

Proposition: Proposizione

Lemma: Lemma

Proof: I have a truly marvelous proof of this proposition that this margin is too narrow to contain.

Youtube

Nonostante preferirei evitare di appoggiarmi troppo a servizi esterni di cui non approvo le politiche ho predisposto una macro per includere video a Youtube.

{youtube:dQw4w9WgXcQ}

Aciinema

Personalmente mi piace molto Asciinema e in generale l’idea di non dover usare gif animate per raggiungere scopi analoghi. Mi piace meno l’idea di dovermi affidare anche a loro per l’hosting dei miei cast, pertanto ho presisposto una macro per includere i cast hostandoli direttamente in questo spazio.

{asciinema:neofetch}

Proviamo Iosevka Comfy

module Amb (AmbT, Amb, amb, cut, runAmbT, runAmb) where

import Control.Monad.Cont
import Control.Monad.State
import Control.Monad.Identity

newtype AmbT r m a = AmbT { unAmbT :: StateT [AmbT r m r] (ContT r m) a }
type Amb r = AmbT r Identity

instance MonadTrans (AmbT r) where
    lift = AmbT . lift . lift

instance (Monad m) => Monad (AmbT r m) where
    AmbT a >>= b = AmbT $ a >>= unAmbT . b
    return = AmbT . return

backtrack :: (Monad m) => AmbT r m a
backtrack = do xss <- AmbT get
               case xss of
                 [] -> fail "amb tree exhausted"
                 (f:xs) -> do AmbT $ put xs; f; return undefined

addPoint :: (Monad m) => (() -> AmbT r m r) -> AmbT r m ()
addPoint x = AmbT $ modify (x () :)

amb :: (Monad m) => [a] -> AmbT r m a
amb []     = backtrack
amb (x:xs) = ambCC $ \exit -> do
               ambCC $ \k -> addPoint k >> exit x
               amb xs
    where ambCC f = AmbT $ callCC $ \k -> unAmbT $ f $ AmbT . k

cut :: (Monad m) => AmbT r m ()
cut = AmbT $ put []

runAmbT :: (Monad m) => AmbT r m r -> m r
runAmbT (AmbT a) = runContT (evalStateT a []) return

runAmb :: Amb r r -> r
runAmb = runIdentity . runAmbT

{video:pueblo-unido.webm}

I have no musical pretensions, I’m not a musician and I studied this piece for fun in my spare time. I also wanted to try to record the analog output of the digital piano¹ using a normal integrated audio board, to check the quality. I have to say that I’m pleasantly impressed by the low background noise. I’ve used Audacity to record the audio and Openshot to put put together the audio and the video.

It would have been cool to save the midi and then synthetize the audio, however I had no fortune finding a good open source application to do that, I tried FluidSynth with different soundfonts but the internal synthetizer of the piano sounded better in my opinion. I intend to investigate further.

On the contrary, I found several nice and open source generic synthetizers, like ZynAddSubFX, despite I’m not into electronic music I like progressive rock and related. Maybe one day I will spend some time on it…

Note: Questo post nasce pochi giorni dopo un seminario che ho dovuto tenere in Universitá, infatti, dopo aver approfondito l’argomento che sto per esporre, mi spiaceva lasciare tali concetti “al vento” e mi sembrava sensato trascriverli nero su bianco da qualche parte. L’idea iniziale era di scrivere un bel documento in \(\LaTeX\) di cui farne un pdf da perdere in qualche remota cartella del pc, ma alla fine mi sono detto: perché non qui sul blog?

L’obiettivo di queste note é di fornire una semplice e concisa esposizione del teorema di Sard, noto risultato di geometria differenziale. La trattazione é carica di osservazioni e frequenti definizioni, in modo da essere digeribile anche ai non addetti ai lavori.

Definition: Siano \((a_1, \dots, a_n), (b_1, \dots, b_n) \in \R^n\) tali che \(a_i < b_i\), chiamiamo rettangolo solido n-dimensionale l’insieme \[ S(a, b)=\{(x_1, \dots, x_n) \in \mathbb{R}^n : a_i \lt x_i \lt b_i\} \]

Definition: Chiamiamo volume n-dimensionale di un rettangolo solido n-dimensionale \(S(a, b)\) la quantitá reale positiva \[ Vol(S(a, b)) = \prod_{i=1}^n (b_i - a_i) \]

Definition: Diciamo che \(A \subset \R^n\) ha misura nulla se \(\forall \epsilon \gt 0\) esiste un ricoprimento \(\{S_i\}_{i \in \N}\) di \(A\) (ovvero \(\bigcup_{i \in \N} S_i \supset A\)) formato da rettangoli solidi \(S_i\) tale che \[ \sum_{i \in \mathbb{N}} Vol(S_i) \lt \epsilon \]

Osserviamo innanzitutto che, nella definizione di insieme a misura nulla, considerare cubi n-dimensionali (cioé rettangoli dove \(b_i - a_i = b_j - a_j \forall i, j\)) invece che rettangoli é del tutto equivalente. D’altronde é del tutto equivalente anche considerare le palle euclidee o in generale le altre bolle indotte da norme equivalenti (nel senso che generano la stessa topologia).

Inoltre, si segnala come tale nozione sia equivalente all’avere misura di Lebesgue nulla, ovvero \(A\) ha misura nulla se e solo se \(m_n(A) = 0\) dove \(m_n\) é la misura di Lebesgue n-dimensionale. La dimostrazione di tale equivalenza, nonostante non di difficile raggiungimento, non é necessaria per i nostri obiettivi e pertanto verrá omessa.

Iniziamo con le due seguenti banali osservazioni:

Observation: Se \(m \lt n\) allora \(\R^m\) ha misura nulla in \(\R^n\)

Proof: Basta ricoprire \(\R^m\) con una famiglia numerabile di cubi, tali cubi giacciono su un iano di \(\R^n\) e quindi ognuno di essi puó essere schiacciato in una direzione ortogonale a questo pano. In questo modo l’unione dei rettangoli continua a contenere tutto \(\R^m\) e il volume di ogni rettangolo é piccolo a piacere, questo implica che anche la somma di tutti i volumi é piccola a piacere.

Observation: \(\bigcup_{i \in \N} A_i\) ha misura nulla se ogni \(A_i\) ha misura nulla.

Proof: Unioni di famiglie numerabili sono ancora numerabili per l’assioma della scelta.

Vediamo ora una prorietá fondamentale che ci permettá in seguito di estendere la definizione di insiemi a misura nulla.

Proposition: Sia \(F: U \to \R^n\) una mappa liscia, con \(U \subset \R^n\) aperto. Se \(A \subset U\) ha misura nulla allora anche l’immagine \(F(A)\) ha misura nulla.

Proof: Iniziamo osservando che \(U\) é ricopribile da una famiglia numerabile di palle chiuse per cui la restrizione di \(F\) ad ognuna di queste palle é ancora liscia, ricordiamo che una mappa é liscia su un insieme generico (non aperto) se essa é estendibile ad una mappa liscia definita su un aperto contenente tale insieme. Sia \(\bar{B}\) una di queste palle, siccome \(\bar{B}\) é compatto e \(F \in \mathscr{C}^1(\bar{B})\) allora \(\exists c \gt 0\) tale che \(\forall x, y \in \bar{B}\)

\[ \Vert F(x) - F(y) \Vert \le c \Vert x-y \Vert \]

Fissiamo \(\delta \gt 0\), visto che \(A \cap \bar{B}\) ha misura nulla possiamo considerare un suo ricoprimento numerabile \(\{ B_k \}_{k \in \N}\) di palle tale che

\[ \sum_{k \in \N} Vol({B_k}) \lt \delta \]

Per la diseguaglianza di prima sappiamo che \(F(B_k \cap \bar{B})\) é contenuto in una palla di raggio al piú \(c\) volte il raggio di \(B_k\). Dunque \(F(A \cap B_k)\) é ricoperto da una famiglia numerabile \(\{ \tilde{B_k} \}_{k \in \N}\) di palle di volume complessivo inferiore a

\[ \sum_{k \in \N} Vol({\tilde{B_k}}) \lt c^n \delta \]

Per arbitrarietá di \(\delta\) segue che \(F(A \cap \bar{B})\) ha misura nulla, e dunque per quanto osservato all’inizio che anche \(F(A)\) ha misura nulla, cioé la tesi.

Ció implica che l’avere dimensione nulla é invariante per diffeomorfismi, siamo quindi ora pronti ad estendere la definizione di insiemi a misura nulla alle varietá differenziabili, prima di fare ció enunciamo e dimostriamo una versione piú debole del teorema di Sard. Per capire in che modo questo teorema é implicato dalla versione generale occorrerá attendere ancora un poco.

Theorem (Mini-Sard): Sia \(F: U \sub \R^m \to \R^n\) una mappa liscia, con \(U\) aperto e \(m < n\). Allora l’immagine \(F(\R^m)\) ha misura nulla in \(\R^n\).

Proof: Sia \(\pi: \R^n \to \R^m\) la proiezione sulle prime \(m\) componenti, tale mappa é liscia. Consideriamo ora l’aperto \(\tilde{U} = \pi^{-1}(U) \sub \R^n\) e \(\tilde{F} = F \circ \pi: \R^n \to \R^n\), che é ancora liscia. A questo punto é sufficiente osservare che \(F(U)\) non é nient’altro che l’immagine di \(\tilde{U} \cap \R^m\) attraverso \(\tilde{F}\), che, per la proposizione precedente, ha misura nulla siccome é l’immagine di un insieme a misura nulla (é tutto contenuto in un iperpiano!) attraverso una funzione liscia.

Come preannunciato, estendiamo la definizione di insieme a misura nulla sulle varietá differenziali.

Definition (Insiemi a misura nulla su varietá differenziabili): Sia \(M\) una varietá differenziale, diciamo che \(A \sub M\) ha misura nulla se \(\varphi(A_i \cap U_i)\) ha misura nulla in \(\R^{dim(M)}\) per ogni carta \((U, \varphi)\) dell’atlante di \(M\).

Si osserva che, a causa della \(\mathscr{C}^\infty\)-compatibilitá delle carte dell’atlante, per affermare che un sottoinsieme della varietá ha misura nulla é sufficiente trovare una collezione numerabile di carte che ricoprano l’insieme candidato e che soddisfino l’enunciato della definizione. In particolare se l’insieme é tutto contenuto in una carta, per mostrare che ha misura nulla basta verificare che l’immagine attraverso la carta ha misura nulla.

Passiamo ora a definire un altro concetto che sará fondamentale per enunciare il Teorema di Sard.

Definition (Punti critici e valori critici): Sia \(F: M \to N\) una mappa liscia tra varietá differenziali, diciamo che \(p \in M\) é un punto critico se la mappa differenziale indotta \(dF_p: T_P \to T_{F(p)}N\) non é suriettiva. In tal caso \(F(p)\) si dice valore critico.

Denotiamo con \(Crit(F)\) l’insieme dei punti critici di \(F\).

Definition (Punti regolari e valori regolari): Sia \(F: M \to N\) una mappa liscia tra varietá differenziali, diciamo che \(p \in M\) é un punto regolare se non é critico, ovvero se \(dF_p: T_p \to T_{F(p)}N\) é suriettiva (ovvero locamente \(F\) é una sommersione). Se \(p'\) é un punto regolare per ogni punto sulla fibra \(F^{-1}(F(p))\) allora \(F(p)\) si dice valore regolare.

Osserviamo come affinché un valore sia critico é sufficiente che esso sia l’immagine di un solo punto critico, mentre affinché sia regolare occorre che tutti i punti della sua controimmagine siano regolari.

La seguente osservazione ci sará utile durante la dimostrazione del teorema di Sard.

Observation: \(Crit(F)\) é un chiuso di \(M\)

Proof: \(Crit(F)=h^{-1}(0)\) dove \(h: M \to \R\) é la mappa liscia tale che

\[h(p)=det(J(F)\bigr|_p \cdot (J(F)\bigr|_p)^t)\]

cioé la mappa che manda i punti della varietá nel determinante del prodotto della Jacobiana con la sua trasposta.

Prima di presentare il teorema di Sard occorre ancora dare una definizione ed enunciare il teorema di Fubini, di cui peró ometteremo la dimostrazione ¹. Tale risultato sará fondamentale nella dimostrazione del teorema di Sard.

Definition (Sezione verticale): Sia \(\R^n = \R^k \times \R^l\) e \(a \in \R^k\), chiamiamo sezione verticale l’insieme \(V_a = \{ a \} \times \R^l\).

Sempre adottando le notazioni della definizione, diremo che un insieme \(A \sub \R^n\) ha sezione verticale nulla se la proiezione (sulle ultime l componenti) di \(V_a \cap A\) in \(\R^l\) ha misura nulla.

Theorem (Teorema di Ruffini): Sia \(A \sub \R^n = \R^k \times \R^l\), se tutte le sezioni verticali \(V_a\) hanno misura nulla (quindi \(\forall a \in \R^k\)) allora \(A\) ha misura nulla in \(\R^n\).

Enunciamo finalmente il teorema di Sard:

Theorem (Teorema di Sard): Sia \(F: M \to N\) una mappa liscia tra varietá differenziabili, allora l’insieme dei valori critici \(F(Crit(F))\) ha misura nulla in \(N\).

Siccome per le varietá differenziabili vale il secondo assioma di numerabilitá ogni insieme é ricopribile con una collezione numerabile di carte, pertanto nell’enunciato del teorema é sufficiente chiedere che il dominio di F sia un singolo aperto \(U \sub \R^m\), dove \(m = dim(M)\). Inoltre, per lo stesso motivo, anche l’immagine \(F(U)\) é ricopribile con una collezione numerabile di carte, pertanto anche qui si puó supporre senza perdita di generalitá che la carta sia una sola, ovvero che l’immagine \(F(U)\) stia in \(\R^n\), dove \(n = dim(N)\).

Quanto appena scritto é sufficiente a giustificare la seguente formulazione equivalente del teorema di Sard.

Theorem (Teorema di Sard, formulazione equivalente): Sia \(F: U \sub \R^m \to \R^n\) una mappa liscia, con \(U\) aperto. Allora l’insieme dei valori critici \(F(Crit(F))\) ha misura nulla in \(\R^n\).

Proof: Se \(m \lt n\) l’enunciato diventa una semplice conseguenza del Teorema Mini-Sard, supponiamo dunque \(m \geq n\) e procediamo per induzione su \(m\).

Se \(m = 0\) allora l’immagine dei punti critici deve essere contenuta in un punto, e pertanto non puó che avere misura nulla. Supponiamo quindi ora il teorema valido per \(m-1\) e dimostriamolo per \(m\).

Chiamiamo ora per brevitá \(C = Crit(F)\) e \(C_i = \{ p \in U : \frac{\partial^k F}{\partial \dots} \bigr|_p = 0, \forall k \leq i \}\), ovvero l’insieme dei punti di \(U\) in cui tutte le derivate di ordine inferiore a \(i\) si annullano.

Osserviamo subito come \(C\) e i \(C_i\) sono chiusi (dimostrazione simile all’osservazione iniziale sulla chiusura di \(C\)), inoltre ha luogo la seguente catena di inclusioni:

\[C \supset C_1 \supset C_2 \supset \dots\]

Assumiamo ora i tre seguenti lemmi, rimandandone temporaneamente la dimostrazione, che ricordiamo avverrá per induzione su \(m\).

• Lemma a \(F(C \setminus C_1)\) ha misura nulla in \(\R^n\)
• Lemma b \(F(C_i \setminus C_{i+1})\) ha misura nulla in \(\R^n\)
• Lemma c \(F(C_k)\) ha misura nulla in \(\R^n\) se \(k \gt \frac{m}{n} - 1\)

Per concludere il teorema ora é sufficiente osservare che

\[F(C) = F(C \setminus C_1) \cup \bigcup_{i=1}^{\floor{\frac{m}{n}-1}} F(C_i) \setminus F(C_{i+1}) \cup F(C_{\ceil{\frac{m}{n}-1}})\]

Ovvero che l’insieme dei valori critici é unione finita di insiemi che sono a misura nulla per i tre lemmi, e pertanto anch’esso ha misura nulla.

Seguono le dimostrazioni dei tre lemmi, ricordiamo che ci troviamo sotto ipotesi induttive, pertanto potremo assumere il teorema di Sard valido per \(m-1\).

Lemma (a): \(F(C \setminus C_1)\) ha misura nulla in \(\R^n\)

Proof: Osserviamo come sia sufficiente mostrare che per ogni punto in \(C \setminus C_1\) esiste un intorno \(V\) per cui \(f(C \cap V)\) ha misura nulla. Infatti siccome \(U\) é un aperto di \(\R^m\), vale il secondo assioma di numerabilitá, e quindi é possibile ricoprire \(C \setminus C_1\) di intorni la cui immagine ha misura nulla.

Consideriamo quindi \(\tilde{x} \in C \setminus C_1\), visto che \(\tilde{x} \not\in C_1\) possiamo assumere senza perdita di generalitá che \(\frac{\partial f}{\partial x_1}\) sia non nulla in \(\tilde{x}\), a questo punto definiamo una mappa \(h: U \to \R^m\) tale che

\[h(x_1, \dots, x_m) = (f_1(x), x_2, \dots, x_m)\]

Questa mappa ha rango massimo in \(\tilde{x}\) e quindi é un diffeomorfismo locale per un qualche intorno aperto di \(\tilde{x}\), continuiamo a chiamare \(h: V \sub U \to V' \sub \R^m\) il diffeomorfismo ottenuto dalla restrizione.

Definiamo ora la mappa composta \(g = f \circ h^{-1} : V' \to \R^n\) e chiamiamo \(C' = Crit(g)\), osserviamo subito che \(C' = h(C \cap V)\); ma allora \(g(C') = g(h(C \cap V)) = f(h(h^{-1}(C \cap V))) = f(C \cap V)\) e quindi per mostrare la tesi basta mostrare che \(g(C')\) ha misura nulla.

Osservando che \(g_1 = f_1 \circ h_1^{-1} = id\) si vede che \(g\) é la funzione identitá sulla prima coordinata, questo permette di definire per ogni \(t\) la mappa \(g^t: ({t} \times \R^{m-1} \to {t} \times \R^{n-1})\) dove

\[g^t(x_2, x_3, \dots, x_m) = (g_2(t, x_2, \dots, x_m), \dots, g_m(t, x_2, \dots, x_m))\]

I punti critici di questa mappa coincidono coi punti critici della sezione verticale di \(C'\), ovvero \(C' \cap V_t = \{ t \} \times Crit(g^t)\). Questo implica che \(g(C') \cap V_t = \{ t \} \times g^t(C)\), ovvero che le varie sezioni verticali dei valori critici di \(g\) coincidono con i valori critici di \(g^t\), che peró hanno misura nulla per ipotesi induttiva!

Questo basterebbe a concludere grazie al teorema di Fubini, se solo non fosse che mentre \(C'\) é un chiuso non é detto che anche \(g(C')\) sia un chiuso (serve che lo sia affinché sia possibile applicare il teorema di Fubini). Questo problema é facilmente superabile osservando che \(C'\) é unione numerabile di compatti (é un chiuso di \(U\)) e quindi anche l’immagine \(g(C')\) é unione numerabile di compatti, pertanto non assumere \(C'\) chiuso non é lmitante.

Lemma (b): \(F(C_i \setminus C_{i+1})\) ha misura nulla in \(\R^n\)

Proof: La dimostrazione é simile a quella del lemma precedente, infatti dimostreremo che \(\forall x \in C_i \setminus C_{i+1}\) troviamo un intorno \(V\) di \(x\) tale che \(f(C_i \cap V)\) ha misura nulla, per le stesse motivizaioni del lemma precedente questo é sufficiente a concludere la dimostrazione.

Sia \(\tilde{x} \in C_i \setminus C_{i+1}\), siccome \(\tilde{x} \not \in C_{i+1}\) significa che possiamo trovare una derivata \(k+1\)-esima di \(f\) non nulla in \(\tilde{x}\). Senza perdita di generalitá assumiamo quindi che esista una derivata \(k\)-esima \(\rho: U \to \R^n\) tale che \(\frac{\partial \rho_1}{\partial x_1}\) sia non nulla in \(\tilde{x}\).

Definiamo a questo punto una mappa \(h: U \to \R^m\) tale che

\[h(x_1, \dots, x_m) = (\rho_1(x_1, \dots, x_m), \dots, x_m)\]

Come nella dimostrazione del lemma precedente, siccome tale mappa ha rango massimo in \(\tilde{x}\), esistono \(x \in V \sub U \sub \R^m\) e \(V' \sub \R^n\) aperti diffeomorfi attraverso la restrizione di \(h\), che continueremo a chiamare \(h\). Per costruzione \(h(C_k \cap V)\) é contenuto nell’iperpiano \(\{ 0 \} \times \R^{m-1}\), e quindi \(g = f \circ h^{-1}\) ha i punti critici di tipo \(C_k\) in tale iperpiano.

Definiamo \(\tilde{g}\) come la restrizione di \(g\) data da \(\tilde{g}: (\{ 0 \} \times \R^{m-1}) \cap V' \to \R^n\), per induzione vediamo che i suoi valori critici hanno misura nulla, ma i suoi punti critici coincidono coi punti critici di tipo \(C_k\) di \(g\), e quindi l’immagini di tali punti, ovvero \(f(C_k \cap V)\), ha misura nulla.

Lemma (c): \(F(C_k)\) ha misura nulla in \(\R^n\) se \(k \gt \frac{m}{n} - 1\)

Proof: Siccome \(C_k\) é ricopribile da una collezione numerabile di cubi contenuti in \(U\) di lato \(\delta\), preso uno di questi cubi, diciamo \(S \sub U\), é sufficiente mostrare che \(f(C_k \cap S)\) ha misura nulla per \(k\) sufficientemente grande.

Sia \(x \in C_k \cap S\) e \(x+h \in S\), scrivendo lo sviluppo in serie di Taylor di \(f\) di ordine \(k\) e ricordandoci della compattezza di \(S\) e della definizione di \(C_k\) otteniamo:

\[f(x, h) = f(x) + R(x, h)\]

dove vale la seguente maggiorazione per il resto \(R\)

\[R(x, h) \lt a ||h||^{k+1}\]

\(a \in \R\) é costante e dipende solo da \(f\) e \(S\). A questo punto possiamo suddividere il cubo \(S\) in \(r^m\) cubi di lato \(\frac{\delta}{r}\), sia \(\tilde{S}\) uno di questi cubi e sia \(x \in \tilde{S} \cap C_k\), osserviamo come ogni punto di \(\tilde{S}\) sia della forma \(x+h\) dove

\[||h|| \lt \sqrt{m} \cdot \frac{\delta}{r} = diam(\tilde{S})\]

Dalle diseguaglianze di prima otteniamo

\[||f(x,h) - f(x)|| = ||R(x,h)|| \lt a ||h||^{k+1} \lt a ( \sqrt{m} \frac{\delta}{r} )^{k+1}\]

Che significa che un \(diam(f(\tilde{S})) \lt a ( \sqrt{m} \frac{\delta}{r} )^{k+1}\) e che quindi \(f(\tilde{S})\) é contenuto in un cubo di lato \(\frac{b}{r^{k+1}}\) dove \(b = 2a (\sqrt{m} \delta)^{k+1}\).

Questo ragionamento non dipende da una particolare scelta del cubo \(\tilde{S}\) e puó essere effettuato per ogni cubo della suddivisione, dunque \(f(C_k \cap S)\) é ricopribile da una famiglia di \(r^m\) cubi, ognuno di lato \(\frac{b}{r^{k+1}}\). Ma allora la somma dei volumi é minore di

\[r^m (\frac{b}{r^{k+1}})^n = b^n r^{m - (k+1)n} \xrightarrow[r \rightarrow \infty]{} 0\]

Che é equivalente ad affermare che \(\forall \epsilon \gt 0\) troviamo un \(r_0\) sufficientemente grande per cui \(\forall r \gt r_0\) la somma dei volumi dei cubi che ricoprono \(f(C_k \cap S)\) é inferiore di \(\epsilon\), ovvero che \(f(C_k \cap S)\) ha misura nulla.

La dimostrazione di questo lemma termina la dimostrazione del teorema di Sard, seguono gli enunciati di alcuni notevoli risultati interpretabili come corollari.

Observation: Il gruppo di omotopia \(\pi_q(S^n)\) é banale se \(q \lt n\)

Proof: (idea ²) Basta il teorema Mini-Sard, che usato in un certo modo permette di non considerare un punto da \(S^n\) e retrarre (in modo \(\mathscr{C}^{\infty}\)) tramite una proiezione stereografica ad un aperto di \(\R^n\).

Theorem (Teorema del punto fisso di Brouwer ³): Sia \(f: D^n \to D^n\) continua, dove \(D^n\) é il disco \(n\)-dimensionale. Allora \(f\) ammette un punto fisso cioé \(\exists x_0 \in D^n\) tale che \(f(x_0)=x_0\).

Theorem (Teorema di Whitney ⁴): Sia \(M\) una varietá differenziabile \(n\)-dimensionale, allora essa puó essere realizzata come sottovarietá chiusa di \(\R^{2n+1}\) o come sottovarietá immersa di \(\R^{2n}\).

Equivalentemente esiste un embedding proprio di \(M\) in \(\R^{2n+1}\) e una immersione di \(\R^{2n}\).

Per esporre il prossimo risultato (fondamentale nella teoria di Morse) occorre dare alcune definizioni.

Definition (punto critico non degenere): Sia \(f: \R^k \to \R\) una funzione liscia, diciamo che \(p \in \R^k\) é un punto critico non degenere se é un punto critico (cioé la mappa differenziale indotta ivi si annulla) e se l’Hessiana nel punto é non singolare, ovvero

\[det(H(f)\bigr|_p) = det(\Big(\frac{\partial^2 f}{\partial x_i \partial x_j}\Big)_{i, j}) \not = 0\]

Definition (funzione di Morse): Sia \(f: \R^k \to \R\) una funzione liscia, diciamo é una funzione di Morse se tutti i suoi punti non degeneri.

Si puó mostrare ⁵ (lemma di Morse) che le funzioni di Morse hanno la proprietá di essere localmente descrivibili come polinomi di secondo grado, ovvero che esiste sempre un cambio di coordinate per cui

\[f(x_1, \dots, x_k) = f(p) + \bold{x} \cdot H(f)\bigr|_p \cdot \bold{x}^t\]

Diagonalizzando la matrice si riesce addirittura a riscrivere la precedente relazione come

\[f(x_1, \dots, x_k) = f(p) + \sum_{i = 1}^k \epsilon_i x_i^2\]

dove \(\epsilon_i = \pm 1\).

Il teorema di Sard ci permette di affermare ⁶ che queste (belle) funzioni di Morse sono quasi tutte le funzioni liscie, in termini piú precisi

Theorem: Sia \(f: M \to \R\) una funzione liscia definita su una varietá differenziabile \(k\)-dimensionale \(M\), tramite le sue carte possiamo definire sempre \(M\) la funzione liscia

\[f_a(x_1, \dots, x_k) = f(x_1, \dots, x_k) + \sum_{i=1}^k a_i x_i\]

Allora il sottoinsieme di \(\R^k\) degli \(a \in \R^k\) tali che \(f_a\) non é funzione di Morse ha misura nulla.

Now I present my new video, which is 1% music skills, 1% editing skills, 98% coding skills, lo and behold:

{video:musical-offering-python.webm}

This video is generated by a Python script which mainly use two libraries; MoviePy for the video editing (based on ffmpeg) and mido for the midi file reading.

You can find the source here on Github, I created a repository only for this, it also contains the source videos I used, so it’s easier if someone want to try playing with it without recording new videos (that was the more boring part).

The source code is messy and full of hardcoded things which depends on the specific midis, maybe one day I will create a specific Python library for this.

Happy hacking

Note: When I wrote this post (and the script) the last Python version was 3.7, due of its low-level nature, the program no longer works with newer versions. However it should be simple to update it (starting from, for example, changing the magic number) or even better, using this library.

About one month ago I wrote this simple transpiler from Brainfuck to Python bytecode. I’m going to assume you already can “program” in Brainfuck, otherwise I advise you to read the dedicated page on Esolang, in my opinion the best place to learn about the language. I’m also assuming that you have a minimal knowledge about stack machines, personally I only used them as a theoretical objects during some proofs. I learned to use them as a real software only during the creation of this transpiler.

Understanding how to do all of this was not easy because the Python virtual machine is a moving target, I worked with Python 3.7 and I think my program should work with Python 3.6+. The best places to understand how the things work under the hood is the official dis module documentation and this source directly from the Python source code. I recommend to take a look at the first link and to use the second one only for consultation.

I suggest to keep an eye on the source of the program while reading this post.

In the first part of the program there are some imports and the initialization of the cli parser, the interesting part starts with the parse function.

def parse(src):  # parse the brainfuck source
    stack = []  # to remember if inside a [...]
    endAt = {}   # correspondence between brackes [...]

    for i, char in enumerate(src):
        if char == '[':
            stack.append(i)
        elif char == ']':
            endAt[stack.pop()] = i

    def recParse(start=0, end=len(src)-1):  # recursive parser
        ast = []
        i = start

        while i < end:
            char = src[i]
            if char == '+':
                if ast != [] and isinstance(ast[-1], int):
                    ast[-1] = (ast[-1] + 1) % 256
                else:
                    ast.append(1)
            elif char == '-':
                if ast != [] and isinstance(ast[-1], int):
                    ast[-1] = (ast[-1] - 1) % 256
                else:
                    ast.append(255)
            elif char in ('>', '<', '.', ','):
                ast.append(char)
            elif char == '[':
                ast.append('[')
                ast.append(recParse(i+1, endAt[i]))
                ast.append(']')
                i = endAt[i]

            i += 1

        return ast  # return the abstract syntax tree

    return recParse()

That function creates the abstract syntax tree, which is a bit overkill as word because it simply returns a list of lists where the elements can be [, ], ,, ., <, > or an integer ∈ [0, 256). This procedure ignores any character that isn’t one of the standard 8 brainfuck commands and automatically simplify the successions of + and - in a number modulo 256. It would be possible to simplify also < and > but I was too lazy.

The visit function simply depth visits the abstract syntax tree applying the visitor function for every element of the tree.

def visit(visitor, ast):  # depth visit the ast with the visitor function
    for child in ast:
        if isinstance(child, list):
            visit(visitor, child)
        else:
            visitor(child)

Then it’s created a bytearray object called instructions containing some instructions for the stack machine (every instruction is 2 bytes long), that part is mandatory for every programs that the compiler generates, basically it contains some imports.

Instead the global variable addresses is a stack where the top element is the address (as index of instructions) of the last [ met during the compilation.

The real compilation occurs inside visitor, the function itself is basically a big switch statement where different things happen depending on the element of the abstract syntax tree. The only noteworthy branches are [ and ], inside the first one is annotated the address at the top of addresses and then 6 NOP instructions are added to the program so that when the in the second branch ] is met, it’s possible to change the NOP instructions to manage the JUMP instruction.

ast = parse(source)
visit(visitor, ast)

instructions.extend([  # the last instructions for every program
    opmap['LOAD_CONST'], 0,
    opmap['RETURN_VALUE']
])

code = CodeType(
        0,  # argcount
        0,  # kwonlyargcount
        3,  # nlocals
        1000,  # stacksize
        0,  # flags
        bytes(instructions),  # codestring
        (None, *range(257), '', ('end',), arraySize, ('stdin',)),  # consts
        ('print', 'input', 'ord', 'chr', 'sys', 'stdin', 'read'),  # names
        ('array', 'pointer', 'stdin'),  # varnames
        args.outputfile,  # filename
        args.outputfile,  # name
        0,  # firstlineno
        bytes(),  # lnotab
        (),  # freevars
        ()  # cellvars
)


if args.show:
    print(dis(code))  # show the bytecode in a readable format
    exit(0)

with open(args.outputfile, 'wb+') as out:
    # printing the first 16 bytes in the file
    out.write(MAGIC_NUMBER)  # this depends on the Python version
    out.write(bytes([0] * 12))  # because of the pyc file format
    marshal.dump(code, out)

exit(0)

Here the parsing and the visiting (i.e. the instructions creation) are done, then two last instructions are added, they basically let the program return None. Then a CodeType “object” is created, it was not easy to find some documentations about this. At the end the bytearray is serialized and wrote to a file using the marshal module. This is how the .pyc files are structured inside.

Let’s note that before writing the instructions in the file a magic number of 16 bytes is written, it depends on the Python version, so this transpiler should generate bytecode working only with the same Python version used for the interpiler execution.

The complete source code of the program is here on Gist.

Here you can see an usage example where I compile a Brainfuck program which prints an ascii version of a famous fractal.

{asciinema:brainfuck}

For this I have to thanks Daniel Cristofani, an insanely good Brainfuck developer who wrote programs such as the (maybe) shortest possible quine, a Brainfuck interpreter (a.k.a. Meta-circular evaluator) and a Brainfuck to C transpiler.

This project has a lot of possible improvements…

I started defining the boolean values true and false:

\[ T = \lambda x . \lambda y . x \qquad F = \lambda x . \lambda y . y \]

const T = (x) => ((y) => x)
const F = (x) => ((y) => y)

This explicit parenthesization is not necessary but I preferred to exaggerate rather than making the code even more obfuscated. I’m going to follow this choice in the whole source. The purpose of this definition is clarified by the if-then-else statement:

\[ \lambda cond . \lambda a . \lambda b . cond \; a \; b \]

const ifThenElse = (cond) => ((a) => ((b) => cond(a)(b)))

The lists are created consing nodes recursively, a node is a pair (i.e. a cons of two “things”) where:

• if the first element of the pair is T then the node is nil (the empty list), at this point what is the second element of the pair is not relevant
• if the first element of the pair is F then the node is not nil and the content of the node is in its second element.

Using a lisp-like syntax what I’m saying is that the list [1, 2, 3] is something like (cons (node 1) (cons (node 2) (cons (node 3) nil))) where (node a) is (cons F a). In code:

const cons = (a) => ((b) => ((c) => c(a)(b)))
const car = (l) => l(T)
const cdr = (l) => l(F)
const nil = cons(T)(T)
const isNil = car
const node = (x) => cons(F)(x)

And now something a little more interesting; the natural numbers! This construction remembers the inductive definition by Peano.

\[ \begin{aligned} 0 &= \lambda f . \lambda x . x\\ 1 &= \lambda f . \lambda x . f x\\ 2 &= \lambda f . \lambda x . f(f x)\\ \vdots \\ n &= \lambda f . \lambda x \; \underbrace{f(\dots f(f(}_{n} n) \end{aligned} \]

A number \(n\) is simply something that, when called passing a function \(f\) return the composition \(\underbrace{f \circ f \circ \dots \circ f}_n\), with the convention that \(f^0 = id\).

\[ succ(n) = \lambda n . \lambda f .\lambda x . f(n(f)(x)) \]

Now should be obvious what the function succ does. Conversely how the arithmetic operators have been implemented may not appear such obvious.

const isZero = (n) => n((k) => F)(T)
const pred = (n) => ((f) => ((x) => n((g) => ((h) => h(g(f))))((u) => x)((u) => u)))

const plus = (m) => ((n) => ((f) => ((x) => m(f)(n(f)(x)))))
const prod = (m) => ((n) => ((f) => ((x) => m(n(f))(x))))
const exp = (m) => ((n) => ((f) => ((x) => n(m)(f)(x))))
const minus = (m) => ((n) => n(pred)(m))

I suggest to equip yourself with paper and pen, I personally had some difficults untangling these lambdas. A really nice place where to learn how this functions work is this page on wikipedia. I urge you to notice that this isn’t the only possible implentation, even continuing to use the Church numerals (the representation used here for the numbers). However, as the names say, these functions implement the addition, the multiplication, the exponentiation and the subtraction. isZero is a boolean predicate which tells if a numeral is \(0\) and pred returns the predecent. I enfatize how implementing the subtraction without pred wouldn’t have benn easy.

The next logic operators and the comparator of numbers are easy to understand, it’s sufficient the remember what a boolean value and a number really are.

const not = (a) => ifThenElse(a)(F)(T)
const and = (a) => ((b) => a(b)(a))
const or = (a) => ((b) => a(a)(b))
const xor = (a) => ((b) => a(not(b))(b))

const leq = (m => ((n) => isZero(minus(m)(n))))
const eq = (m => ((n) => and(leq(m)(n))(leq(n)(m))))
const lt = (m => ((n) => and(leq(m)(n))(not(eq(m)(n)))))

Last but not least the the factorial function! Implemented without the infamous Y combinator, that should merit a whole post only for itself. (maybe in the future)

const fac = (n) => n(c => ((q) => q(succ(c(T)))(prod(c(T))(c(F)))))((q) => one)(F)

And now feel free to play with this code directly in this page, for example you can try to calcolate the factorial of \(7\) whith lambdaToInt(fac(intToLambda(7))), not bad if you consider how the function has been defined. I suggest to use the functions boolToLambda, lambdaToBool, intToLambda, lambdaToInt, listToLambda and lambdaToList to create and get boolean values, integers and lists. How do they works is auto-explanatory, however you can find the whole source at the end of this page.

The complete source:

const T = (x) => ((y) => x)
const F = (x) => ((y) => y)
const ifThenElse = (cond) => ((a) => ((b) => cond(a)(b)))

const cons = (a) => ((b) => ((c) => c(a)(b)))
const car = (l) => l(T)
const cdr = (l) => l(F)
const nil = cons(T)(T)
const isNil = car
const node = (x) => cons(F)(x)

const zero = (f) => ((x) => x)
const one = (f) => ((x) => f(x))
const two = (f) => ((x) => f(f(x)))
const succ = (n) => ((f) => ((x) => f(n(f)(x))))
const three = succ(two)
const four = succ(three)
const five = succ(four) //etc...

const isZero = (n) => n((k) => F)(T)
const pred = (n) => ((f) => ((x) => n((g) => ((h) => h(g(f))))((u) => x)((u) => u)))

const plus = (m) => ((n) => ((f) => ((x) => m(f)(n(f)(x)))))
const prod = (m) => ((n) => ((f) => ((x) => m(n(f))(x))))
const exp = (m) => ((n) => ((f) => ((x) => n(m)(f)(x))))
const minus = (m) => ((n) => n(pred)(m))

const not = (a) => ifThenElse(a)(F)(T)
const and = (a) => ((b) => a(b)(a))
const or = (a) => ((b) => a(a)(b))
const xor = (a) => ((b) => a(not(b))(b))

const leq = (m => ((n) => isZero(minus(m)(n))))
const eq = (m => ((n) => and(leq(m)(n))(leq(n)(m))))
const lt = (m => ((n) => and(leq(m)(n))(not(eq(m)(n)))))

const fac = (n) => n(c => ((q) => q(succ(c(T)))(prod(c(T))(c(F)))))((q) => one)(F)

//These functions simply help to see and create integers, booleans and lists
function lambdaToBool(b) {
  return ifThenElse(b)(true)(false);
}

function boolToLambda(b) {
  return b ? T : F;
}

function lambdaToInt(n) {
  return n((x) => x + 1)(0);
}

function intToLambda(n) {
  if(n === 0) return zero;
  else return plus(one)(n == 1 ? zero : intToLambda(n-1));
}

function listToLambda(l) {
  var nl = nil;
  for(var e of l.reverse())
    nl = cons(node(e))(nl)
  return nl;
}

function lambdaToList(l) {
  var a = [];
  while(lambdaToBool(not(isNil(car(cdr(l)))))) {
    a.push(cdr(car(l)))
    l = cdr(l)
  }
  return a;
}

In this post I’m going to explain how I implemented the famous Marching cubes³ algorithm. I want to underline the fact that I’m not an expert, I discovered this algorithm some days ago because I wanted display two Metaballs, so this post is for fun, simply don’t expect a super-efficient implementation.

This is my final result, I hope you like it.

Let’s try to move around the metaballs using the mouse!

var triTable = [
	[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1],
	[3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1 , -1, -1, -1],
	[1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1],
	[3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1],
	[3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1],
	[9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1],
	[9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1],
	[2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1],
	[8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1],
	[9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1],
	[4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1],
	[3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1],
	[1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1],
	[4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1],
	[4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1],
	[9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1],
	[5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1],
	[2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1],
	[9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1],
	[0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1],
	[2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1],
	[10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1],
	[4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1],
	[5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1],
	[5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1],
	[9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1],
	[0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1],
	[1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1],
	[10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1],
	[8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1],
	[2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1],
	[7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1],
	[9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1],
	[2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1],
	[11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1],
	[9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1],
	[5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1],
	[11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1],
	[11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1],
	[1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1],
	[9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1],
	[5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1],
	[2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1],
	[0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1],
	[5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1],
	[6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1],
	[3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1],
	[6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1],
	[5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1],
	[1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1],
	[10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1],
	[6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1],
	[8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1],
	[7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1],
	[3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1],
	[5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1],
	[0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1],
	[9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1],
	[8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1],
	[5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1],
	[0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1],
	[6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1],
	[10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1],
	[10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1],
	[8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1],
	[1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1],
	[3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1],
	[0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1],
	[10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1],
	[3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1],
	[6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1],
	[9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1],
	[8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1],
	[3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1],
	[6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1],
	[0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1],
	[10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1],
	[10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1],
	[2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1],
	[7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1],
	[7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1],
	[2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1],
	[1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1],
	[11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1],
	[8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1],
	[0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1],
	[7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1],
	[10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1],
	[2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1],
	[6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1],
	[7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1],
	[2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1],
	[1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1],
	[10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1],
	[10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1],
	[0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1],
	[7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1],
	[6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1],
	[8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1],
	[9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1],
	[6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1],
	[4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1],
	[10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1],
	[8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1],
	[0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1],
	[1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1],
	[8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1],
	[10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1],
	[4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1],
	[10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1],
	[5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1],
	[11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1],
	[9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1],
	[6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1],
	[7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1],
	[3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1],
	[7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1],
	[9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1],
	[3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1],
	[6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1],
	[9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1],
	[1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1],
	[4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1],
	[7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1],
	[6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1],
	[3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1],
	[0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1],
	[6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1],
	[0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1],
	[11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1],
	[6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1],
	[5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1],
	[9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1],
	[1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1],
	[1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1],
	[10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1],
	[0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1],
	[5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1],
	[10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1],
	[11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1],
	[9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1],
	[7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1],
	[2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1],
	[8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1],
	[9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1],
	[9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1],
	[1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1],
	[9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1],
	[9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1],
	[5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1],
	[0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1],
	[10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1],
	[2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1],
	[0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1],
	[0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1],
	[9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1],
	[5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1],
	[3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1],
	[5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1],
	[8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1],
	[0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1],
	[9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1],
	[0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1],
	[1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1],
	[3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1],
	[4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1],
	[9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1],
	[11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1],
	[11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1],
	[2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1],
	[9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1],
	[3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1],
	[1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1],
	[4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1],
	[4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1],
	[0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1],
	[3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1],
	[3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1],
	[0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1],
	[9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1],
	[1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
	[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
];

function lerp(sf, isolevel, x0, y0, z0, x1, y1, z1) {
	let sf0 = sf(x0, y0, z0);
	let sf1 = sf(x1, y1, z1);
	let mu = (isolevel - sf0) / (sf1 - sf0);
	return new THREE.Vector3(x0 + mu * (x1 - x0), y0 + mu * (y1 - y0), z0 + mu * (z1 - z0));
}

function realPos(n, sf, iso, x, y, z, step) {
	switch (n) {
		case 0:
			return lerp(sf, iso, x, y, z, x + step, y, z);
		case 1:
			return lerp(sf, iso, x + step, y, z, x + step, y + step, z);
		case 2:
			return lerp(sf, iso, x + step, y + step, z, x, y + step, z);
		case 3:
			return lerp(sf, iso, x, y + step, z, x, y, z);
		case 4:
			return lerp(sf, iso, x, y, z + step, x + step, y, z + step);
		case 5:
			return lerp(sf, iso, x + step, y, z + step, x + step, y + step, z + step);
		case 6:
			return lerp(sf, iso, x + step, y + step, z + step, x, y + step, z + step);
		case 7:
			return lerp(sf, iso, x, y + step, z + step, x, y, z + step);
		case 8:
			return lerp(sf, iso, x, y, z, x, y, z + step);
		case 9:
			return lerp(sf, iso, x + step, y, z, x + step, y, z + step);
		case 10:
			return lerp(sf, iso, x + step, y + step, z, x + step, y + step, z + step);
		case 11:
			return lerp(sf, iso, x, y + step, z, x, y + step, z + step);
	}
}

function createGeometry(scalarField, isolevel, startVector, endVector, res) {
	let geom = new THREE.Geometry();
	let nVert = 0;
	let xStep = (endVector.x - startVector.x) / res;
	let yStep = (endVector.y - startVector.y) / res;
	let zStep = (endVector.z - startVector.z) / res;
	for (let x0 = startVector.x; x0 < endVector.x; x0 += xStep) {
		for (let y0 = startVector.y; y0 < endVector.y; y0 += yStep) {
			for (let z0 = startVector.z; z0 < endVector.z; z0 += zStep) {
				let cubeIndex = 0;
				if (scalarField(x0, y0, z0) < isolevel) cubeIndex |= 1;
				if (scalarField(x0 + xStep, y0, z0) < isolevel) cubeIndex |= 2;
				if (scalarField(x0 + xStep, y0 + yStep, z0) < isolevel) cubeIndex |= 4;
				if (scalarField(x0, y0 + yStep, z0) < isolevel) cubeIndex |= 8;
				if (scalarField(x0, y0, z0 + zStep) < isolevel) cubeIndex |= 16;
				if (scalarField(x0 + xStep, y0, z0 + zStep) < isolevel) cubeIndex |= 32;
				if (scalarField(x0 + xStep, y0 + yStep, z0 + zStep) < isolevel) cubeIndex |= 64;
				if (scalarField(x0, y0 + yStep, z0 + zStep) < isolevel) cubeIndex |= 128;
				faces = triTable[cubeIndex];
				for (let i = 0; faces[i] != -1; i += 3) {
					nVert += 3;
					let v1 = realPos(faces[i], scalarField, isolevel, x0, y0, z0, xStep);
					let v2 = realPos(faces[i + 1], scalarField, isolevel, x0, y0, z0, yStep);
					let v3 = realPos(faces[i + 2], scalarField, isolevel, x0, y0, z0, zStep);
					geom.vertices.push(v1);
					geom.vertices.push(v2);
					geom.vertices.push(v3);
					geom.faces.push(new THREE.Face3(nVert - 3, nVert - 2, nVert - 1));
				}
			}
		}
	}
	geom.mergeVertices();
	geom.computeFaceNormals();
	geom.computeVertexNormals();
	return geom;
}