Crash (VM Failed) when OSC message is received

TKyubi

        import oscP5.*;

        ArrayList<KochLine> lines;
        ArrayList<SierpTri> triangles;

        OscP5 oscP5;

        int cellsize = 2; 
        int cols, rows; 

        int rect;
        int cycle;
        int tri;

        void setup() {
          size(600, 692, P3D);
          background(255);

          cols = width/cellsize;              // Calculate # of columns
          rows = height/cellsize;             // Calculate # of rows


          // inizializza colori
          rect = 65;
          cycle = 261;
          tri = 1046;

          oscP5 = new OscP5(this, 8001); // apre udp sulla porta 12000
          // TEST PER LE VARIABILI IN ENTRATA
          oscP5.plug(this, "testG", "/gain"); // test gain
          oscP5.plug(this, "testF1", "/freq1"); // test frequenza primo oscillatore
          oscP5.plug(this, "testF2", "/freq2"); // test frequenza secondo oscillatore
          oscP5.plug(this, "testF3", "/freq3"); // test frequenza terzo oscillatore

          //funzione di inizializzazione per la figura frattale
          init();

          // display della figura iniziale
          for (KochLine l : lines) { 
            l.display();
          }
          for (SierpTri t : triangles) { 
            t.display();
          }

          //carica l'array pixels
          loadPixels();
        }

        void draw() {

          //background variato via OSC
          background(tri, rect, cycle);

          //3D EXPLOSION (Ripresa dall'esempio)

          for (int i = 0; i < cols; i++ ) {
            // Begin loop for rows
            for (int j = 0; j < rows; j++ ) {
              int x = i*cellsize + cellsize/2; // x position
              int y = j*cellsize + cellsize/2; // y position
              int loc = x + y*width;           // Pixel array location
              color c = pixels[loc];       // Grab the color
              float z = map(int(random(40, 140)), 0, 255, 0, mouseX);
              // Translate to the location, set fill and stroke, and draw the rect
              pushMatrix();
              translate(x, y, z); 
              fill(c);
              noStroke();
              rectMode(CENTER);
              rect(0, 0, cellsize, cellsize);
              popMatrix();
            }
          }
        }

        // GENERAZIONE FRATTALE

        public void init() { // funzione per inizializzare il triangolo base del frattale
          lines = new ArrayList<KochLine>();  // inizializza l'array per il KochSnowflake
          triangles = new ArrayList<SierpTri>(); // inizializza l'array per il SierpinskiTriangle

          // inizializza 3 vettori che rappresentano i 3 punti del triangolo iniziale
          PVector a   = new PVector(0, 173);
          PVector b   = new PVector(width, 173);
          PVector c   = new PVector(width/2, 173+width*cos(radians(30)));

          //vengono aggiunte 3 linee all'Array per Koch
          lines.add(new KochLine(a, b));
          lines.add(new KochLine(b, c));
          lines.add(new KochLine(c, a)); 

          //viene aggiunto un triangolo all'Array per Sierpinski
          triangles.add(new SierpTri(a, b, c));
        }

        public void generate() { // funzione ricorsiva per la generazione del frattale

          //dichiara un secondo Array per entrambi i frattali che funge da elemento di ricorsione

          ArrayList recSierp = new ArrayList<SierpTri>();
          ArrayList recKoch = new ArrayList<KochLine>();

          /** Per ogni Triangolo presente all'interno dell'Array base inizializza 6 vettori
           che rappresentano i 3 vertici del triangolo e i 3 mid-point dei lati. Aggiunge
           al secondo Array tre triangoli secondo la regola dei triangoli di Sierpinski
           */
          for (SierpTri t : triangles) {

            PVector a = t.SierpA();
            PVector b = t.SierpB();
            PVector c = t.SierpC();
            PVector d = t.SierpD();
            PVector e = t.SierpE();
            PVector f = t.SierpF();

            recSierp.add(new SierpTri(a, d, e));
            recSierp.add(new SierpTri(d, b, f));
            recSierp.add(new SierpTri(e, f, c));
          }

          /** Per ogni linea presente all'interno dell'Array base inizializza 5 vettori
           che rappresentano i 5 nodi della linea generata dalla regola di Koch. Aggiunge
           al secondo Array per Koch le 4 linee generate dalla regola stessa e al secondo Array 
           per Sierpinski un triangolo generato tramite i 3 nodi centrali della regola di Koch
           */
          for (KochLine l : lines) { // funzione ricorsiva SnowFlake

            PVector a = l.kochA();                 
            PVector b = l.kochB();
            PVector c = l.kochC();
            PVector d = l.kochD();
            PVector e = l.kochE();

            recKoch.add(new KochLine(a, b));
            recKoch.add(new KochLine(b, c));
            recKoch.add(new KochLine(c, d));
            recKoch.add(new KochLine(d, e));

            recSierp.add(new SierpTri(b, c, d)); // aggiunge ogni nuovo triangolo generato al Sierpinski
          }

          // Ricorsione: sostituisce l'array originale con l'array ricorsivo
          lines = recKoch;
          triangles = recSierp;
        }

        // TEST PER I VALORI OSC

        public void testG(float theF) { // test per il gain, chiede un float

          gain2 = map(theF, -76.6, 17.6, 37, 600); // assegna al secondo valore di testGain un valore riscalato

          int gain = test1(theF); 
          // richiama una funzione di test

          /** funzione di switch che assegna ad ogni caso (generato dalla funzione di test
           in base al range dei valori) un livello di iterazione del frattale. Per ogni caso
           la funzione di generazione viene iterata una volta in più.
           Questa è la parte che genera il crash quando riceve il messaggio OSC. Quello che
           non capisco è come mai se generata con Keypressed la stessa funzione non da problemi
           mentre in questo modo genera un errore.
           */
          switch (gain) {
          case 0 : 
            background(255);
            init();
            for (KochLine l : lines) { 
              l.display();
            }
            for (SierpTri t : triangles) { 
              t.display();
            }
            loadPixels();
            break;
          case 1 :
            background(255);
            init();
            generate();
            for (KochLine l : lines) { 
              l.display();
            }
            for (SierpTri t : triangles) { 
              t.display();
            }
            loadPixels();
            break;
          case 2 :
            background(255);
            init();
            for (int i=0; i<2; i++) { 
              generate();
            }
            for (KochLine l : lines) { 
              l.display();
            }
            for (SierpTri t : triangles) { 
              t.display();
            }
            loadPixels();
            break;
          case 3 :
            background(255);
            init();
            for (int i=0; i<3; i++) { 
              generate();
            }
            for (KochLine l : lines) { 
              l.display();
            }
            for (SierpTri t : triangles) { 
              t.display();
            }
            loadPixels();
            break;
          case 4 :
            background(255);
            init();
            for (int i=0; i<4; i++) { 
              generate();
            }
            for (KochLine l : lines) { 
              l.display();
            }
            for (SierpTri t : triangles) { 
              t.display();
            }
            loadPixels();
            break;
          case 5 :
            background(255);
            init();
            for (int i=0; i<5; i++) { 
              generate();
            }
            for (KochLine l : lines) { 
              l.display();
            }
            for (SierpTri t : triangles) { 
              t.display();
            }
            loadPixels();
            break;
          case 6 :
            background(255);
            init();
            for (int i=0; i<6; i++) { 
              generate();
            }
            for (KochLine l : lines) { 
              l.display();
            }
            for (SierpTri t : triangles) { 
              t.display();
            }
            loadPixels();
            break;
          case 7 :
            background(255);
            init();
            for (int i=0; i<7; i++) { 
              generate();
            }
            for (KochLine l : lines) { 
              l.display();
            }
            for (SierpTri t : triangles) { 
              t.display();
            }
            loadPixels();
            break;
          }
        }

        public void testF1(int theA) { // test primo oscillatore
          cycle = int((theA*255)/726); // riscalamento della frequenza tra 0 e 255
        }

        public void testF2(int theB) { // test secondo oscillatore
          rect = int((theB*255)/181);  // riscalamento della frequenza tra 0 e 255
        }

        public void testF3(int theC) { // test terzo oscillatore
          tri = int((theC*255)/2905);  // riscalamento della frequenza tra 0 e 255
        }

        void oscEvent(OscMessage theOscMessage) { // adress di eventuali messaggi non pluggati

          if (theOscMessage.isPlugged()==false) {
            println("### received an osc message.");
            println("### addrpattern\t"+theOscMessage.addrPattern());
            println("### typetag\t"+theOscMessage.typetag());
          }
        }

        // FUNZIONI

        /** funzione di test che genera 7 casi in base al range del valore ricevuto tramite OSC */

        int test1(float a) { 
          if (a < -37) {
            return 0;
          }
          if (a >= -37 && a < -16) {
            return 1;
          }
          if (a >= -16 && a < -12) {
            return 2;
          }
          if (a >= -12 && a < -8) {
            return 3;
          }
          if (a >= -8 && a < -6) {
            return 4;
          }
          if (a >= -6 && a < -4) {
            return 5;
          }
          if (a >= -4 && a < -2) {
            return 6;
          }
          if (a >= -2 && a < -0) {
            return 7;
          }
          return 7;
        }

        // keyPressed di test
        void keyPressed() {
          background(255);
          init();
          generate();
          for (KochLine l : lines) { 
            l.display();
          }
          for (SierpTri t : triangles) { 
            t.display();
          }
          loadPixels();
        }

THE QUESTION: The problem is that when I send via Max/Msp some test values for the "gain test" the patch instantly crashes, I tried cutting of most of the combinations of code lines trying to find the reason, but I couldn't manage to find any explanation for this so I'm here hoping someone can actually explain me what I'm doing wrong.
Thank you very much for your help!