Pen Settings

HTML

CSS

CSS Base

Vendor Prefixing

Add External Stylesheets/Pens

Any URLs added here will be added as <link>s in order, and before the CSS in the editor. You can use the CSS from another Pen by using its URL and the proper URL extension.

+ add another resource

JavaScript

Babel includes JSX processing.

Add External Scripts/Pens

Any URL's added here will be added as <script>s in order, and run before the JavaScript in the editor. You can use the URL of any other Pen and it will include the JavaScript from that Pen.

+ add another resource

Packages

Add Packages

Search for and use JavaScript packages from npm here. By selecting a package, an import statement will be added to the top of the JavaScript editor for this package.

Behavior

Save Automatically?

If active, Pens will autosave every 30 seconds after being saved once.

Auto-Updating Preview

If enabled, the preview panel updates automatically as you code. If disabled, use the "Run" button to update.

Format on Save

If enabled, your code will be formatted when you actively save your Pen. Note: your code becomes un-folded during formatting.

Editor Settings

Code Indentation

Want to change your Syntax Highlighting theme, Fonts and more?

Visit your global Editor Settings.

HTML

              
                <html>

<head>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/0.7.1/p5.min.js"></script>
  <script src="p5.svg.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/0.7.1/addons/p5.dom.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/0.7.1/addons/p5.sound.min.js"></script>
  <link rel="stylesheet" type="text/css" href="style.css">
  <meta charset="utf-8" />

</head>

<body>
  <script src="https://unpkg.com/p5.js-svg@1.3.1"></script>
  <script src="sketch.js"></script>

</body>

</html>
              
            
!

CSS

              
                body {
  margin: 0;
  padding: 0;
  height: 100vh;
  overflow: hidden;
  display: flex;
  align-items: center;
  justify-content: center;
  background: black;
}

              
            
!

JS

              
                //mathober 2022 - will be updated daily
//arrow up/down to switch days, press space to see if the sketch has any randomization

//https://fractalkitty.com/2022/09/17/mathober-2022-prompts/

//@fractalkitty on twitter if you want to share

//Uses: https://github.com/zenozeng/p5.js-svg
let a = 0;
let cnt = 0;
let dayN = -1;
let maxD = 31;
let a1 = [],
  b1 = [],
  c1 = [],
  v1 = [];
function setup() {
  createCanvas(600, 600); //add svg and uncomment bottomlines to save off printer files
  if(dayN === -1){ 
    dayN = day()
  }
  str = ""
  background(255);
  noFill();
  noLoop();
  stroke(0);
  angleMode(DEGREES);
  rectMode(CENTER);
}

function draw() {
  translate(width / 2, height / 2);
  mathoberDay(dayN);
}

function mathoberDay(d) {
  rect(0, 0, 550, 550);
  noFill();
  if (d === 1) {
    strokeWeight(0.5);
    str1 = "Spindle";
    n = 70;
    r1 = 150;
    for (let i = 0; i < n; i++) {
      ellipse(-r1 / 2 + (r1 / n) * i, 0, r1 * cos((180 / n) * i), r1);
    }
    push();
    translate(0, r1 + 5);
    for (let i = 0; i < n; i++) {
      ellipse(-r1 / 2 + (r1 / n) * i, 0, r1 * cos((180 / n) * i), r1);
    }
    pop();
    push();
    translate(0, -r1 - 5);
    for (let i = 0; i < n; i++) {
      ellipse(-r1 / 2 + (r1 / n) * i, 0, r1 * cos((180 / n) * i), r1);
    }
    pop();
  }
  if (d === 2) {
    strokeWeight(0.5);
    str1 = "Cubic";
    n = 20;
    for (let j = 1; j < n; j++) {
      for (let i = -250; i <= 250; i += 7) {
        x = i;
        y = -100 + 0.00001 * x * x * x + j * 10;
        ellipse(x, y, 2 + 20 * sin(j * 5 + i), 2 + 20 * sin(j * 5 + i));
      }
    }
  }
  if (d === 3) {
    strokeWeight(0.5);
    str1 = "Planar";
    n = 30;
    for (let i = -250; i <= 250; i += n) {
      for (let j = -250; j <= 250; j += n) {
        ellipse(i, j, 2, 2);
        if (j < 250) {
          r = random(0, 1);
          if (r > 0.4) {
            line(i, j, i, j + n);
          }
        }
        if (i < 250) {
          if (r > 0.3) {
            line(i, j, i + n, j);
          }
        }
      }
    }
  }
  if (d === 4) {
    strokeWeight(0.5);
    str1 = "Dissection"; //imperfect on purpose to give the feeling of paper.
    push();
    push();
    translate(-120, 50);
    r = 70;
    rf1 = 0.919;
    rf2 = 0.5;
    push();
    for (let i = 0; i < 4; i++) {
      rotate((360 / 4) * i);
      dissectionP();
    }
    pop();
    push();
    translate(0, 70);
    for (let i = 0; i < 4; i++) {
      push();
      translate(50, 50);
      rotate((360 / 4) * i);
      dissectionP();
      pop();
    }
    pop();
    push();
    translate(0, -70);
    for (let i = 0; i < 4; i++) {
      push();
      translate(-50, -50);
      rotate((360 / 4) * i);
      dissectionP();
      pop();
    }
    pop();
    translate(120, -50);
    push();
    for (let i = 0; i < 4; i++) {
      rotate((360 / 4) * i);
      dissectionP();
    }
    pop();
    push();
    translate(0, 70);
    for (let i = 0; i < 4; i++) {
      push();
      translate(50, 50);
      rotate((360 / 4) * i);
      dissectionP();
      pop();
    }
    pop();
    push();
    translate(0, -70);
    for (let i = 0; i < 4; i++) {
      push();
      translate(-50, -50);
      rotate((360 / 4) * i);
      dissectionP();
      pop();
    }
    pop();
    push();
    translate(0, -70);
    for (let i = 0; i < 4; i++) {
      push();
      translate(-50, -50);
      rotate((360 / 4) * i);
      dissectionP();
      pop();
    }
    pop();
    translate(120, -50);
    push();
    for (let i = 0; i < 4; i++) {
      rotate((360 / 4) * i);
      dissectionP();
    }
    pop();
    push();
    translate(0, 70);
    for (let i = 0; i < 4; i++) {
      push();
      translate(50, 50);
      rotate((360 / 4) * i);
      dissectionP();
      pop();
    }
    pop();
    push();
    translate(0, -70);
    for (let i = 0; i < 4; i++) {
      push();
      translate(-50, -50);
      rotate((360 / 4) * i);
      dissectionP();
      pop();
    }
    pop();

    pop();
  }
  if (d === 5) {
    strokeWeight(0.5);
    str1 = "Flat";
    noFill();
    n = 16;
    push();
    for (let i = 0; i < n; i++) {
      line(-250, i * i, 250, i * i);
      line(-250, i * 15, 0, 0);
      line(250, i * 15, 0, 0);
      line(0, 0, i * 17, 250);
      line(0, 0, -i * 17, 250);
    }
    pop();
    push();
    scale(1, -1);
    for (let i = 0; i < n; i++) {
      line(-250, i * i, 250, i * i);
      line(-250, i * 15, 0, 0);
      line(250, i * 15, 0, 0);
      line(0, 0, i * 17, 250);
      line(0, 0, -i * 17, 250);
    }
    pop();
    push();
    for (let j = 0; j < 10; j++) {
      scale(1 - j * 0.05, 1 - j * 0.05);
      beginShape();
      for (let i = -250 - j * j; i < 250 + j * j; i++) {
        vertex(i, 200 * cos(i * 3));
      }
      endShape();
    }
    pop();
  }
  if (d === 6) {
    strokeWeight(0.5);
    str1 = "Hyperbolic";
    n = 13;
    a = 270;
    b = 270;
    for (let i = 0; i < n * 20; i += random(0, 1) * random(0, random(1, 6))) {
      beginShape();
      for (let j = -90; j <= 90; j += 1) {
        x = (a - i) * (1 / cos(j));
        y = (b - i) * tan(j);
        if (x > -250 && y > -250 && x < 250 && y < 250) {
          vertex(x, y);
        }
      }
      endShape();
      beginShape();
      for (let j = 91; j <= 269; j += 1) {
        x = (a - i) * (1 / cos(j));
        y = (b - i) * tan(j);
        if (x > -250 && y > -250 && x < 250 && y < 250) {
          vertex(x, y);
        }
      }
      endShape();
      push();
      rotate(90);
      beginShape();
      for (let j = -90; j <= 90; j += 1) {
        x = (a - i) * (1 / cos(j));
        y = (b - i) * tan(j);
        if (x > -250 && y > -250 && x < 250 && y < 250) {
          vertex(x, y);
        }
      }
      endShape();
      beginShape();
      for (let j = 91; j <= 269; j += 1) {
        x = (a - i) * (1 / cos(j));
        y = (b - i) * tan(j);
        if (x > -250 && y > -250 && x < 250 && y < 250) {
          vertex(x, y);
        }
      }
      endShape();
      pop();
    }
  }
  if (d === 7) {
    strokeWeight(0.5);
    str1 = "Harmonic";
    n = 14;
    for (let i = 1; i <= n; i += 0.2) {
      beginShape();
      for (let j = -225; j <= 225; j += 1) {
        //ellipse(j,(140-i*10)*cos(j*i)-width/4+i*30,3,3)
        vertex(j, min(255, (140 - i * 15) * cos(j * i) - width / 4 + i * 30));
      }
      endShape();
    }
  }
  if (d === 8) {
    strokeWeight(0.5);
    str1 = "Error";
    n = 55;
    m = 7;
    for (let i = 2; i < n; i++) {
      rect(0, 0, i * m, i * m);
    }
    push();
    rotate(10);
    rect(0, 0, m, m);
    pop();
  }
  if (d === 9) {
    strokeWeight(0.5);
    str1 = "Identity";
    n = 90;
    p = 20;
    nd = 4 * int(random(2, 5));
    ellipse(-250, -250, p, p);
    ellipse(250, 250, p, p);
    //arc(-250,-250,900,900,0,90)
    line(-250, -250, -250 + 450, -250);
    line(-250, -250, -250, -250 + 450);
    line(250, 250, 250 - 450, 250);
    line(250, 250, 250, 250 - 450);
    for (let i = 0; i <= n; i = i + random(0, 0.5)) {
      ellipse(
        -250 + 450 * cos(i),
        -250 + 450 * sin(i),
        p * sin(i * nd),
        p * sin(i * nd)
      );
      ellipse(
        250 - 450 * cos(i),
        250 - 450 * sin(i),
        p * sin(i * nd),
        p * sin(i * nd)
      );
      //lines below were playing with Euler's identity
      //line(-250+450*cos(i),-250+450*sin(i),-250,-250)
      //line(-250+450*cos(i),-250+450*sin(i),-250+450*cos(i),-250)
      // line(250-450*cos(i),250-450*sin(i),250,250)
      //line(250-450*cos(i),250-450*sin(i),250-450*cos(i),250)
      line(
        250 - 450 * cos(i),
        250 - 450 * sin(i),
        -250 + 450 * cos(n - i),
        -250 + 450 * sin(n - i)
      );
    }
  }
  if (d === 10) {
    strokeWeight(0.5);
    str1 = "Similar";
    n = 80;
    r = 100;
    a1 = random(10, 80);
    a2 = random(10, 80);

    for (let i = 0; i < n; i += 0.5) {
      r = 10 + 1.4 * i;
      push();
      translate(-20, -20);
      rotate(i * 10);
      translate(r, r);
      triangle(
        0,
        0,
        r * sin(a1),
        r * cos(a1),
        r * sin(a1 + a2),
        r * cos(a1 + a2)
      );
      pop();
    }
  }
  if (d === 11) {
    strokeWeight(0.5);
    str1 = "Fundamental";

    rectMode(CORNER);
    n = int(random(5, 8));
    for (let j = 0; j < 7; j++) {
      push();
      scale(1 - j * 0.1, -1 + j * 0.1);
      beginShape();
      for (let i = -250; i < 250; i++) {
        vertex(i, 0.00001 * i * i * i);
        if (i % n === 0) {
          rect(i - n / 2, 0.00001 * i * i * i, n, -0.00001 * i * i * i);
        }
      }
      endShape();
      beginShape();
      for (let i = -250; i < 250; i++) {
        if (0.01 * i * i < 250) {
          vertex(i, 0.01 * i * i);
        }
        if (i % n === 0) {
          rect(i - n / 2, 0.00001 * i * i * i, n, -0.00001 * i * i * i);
        }
      }
      endShape();
      pop();
    }
  }
  if (d === 12) {
    strokeWeight(0.5);
    str1 = "Category";
    push();
    scale(1, -1);
    function cat1(r, x, y) {
      push();
      translate(x, y);
      for (i = 0; i < r; i += 2) {
        ellipse(0, 0, r - i, r - i);
      }
      line(
        (r / 2) * sin(30),
        (r / 2) * cos(30),
        (r / 2) * 1.5 * sin(50),
        r * 1.5 * cos(50)
      );
      line(
        (r / 2) * sin(90),
        (r / 2) * cos(90),
        (r / 2) * 1.5 * sin(50),
        r * 1.5 * cos(50)
      );
      line(
        (-r / 2) * sin(30),
        (r / 2) * cos(30),
        -((r / 2) * 1.5) * sin(50),
        r * 1.5 * cos(50)
      );
      line(
        (-r / 2) * sin(90),
        (r / 2) * cos(90),
        -((r / 2) * 1.5) * sin(50),
        r * 1.5 * cos(50)
      );
      pop();
    }
    cat1(40, 0, 150);
    cat1(40, 0, 0);
    cat1(40, 0, -150);
    line(0, 100, 0, 50);
    line(0, 100, 10, 90);
    line(0, 100, -10, 90);
    line(0, -50, 0, -100);
    line(0, -50, 10, -60);
    line(0, -50, -10, -60);
    arc(0, 0, 200, 300, -70, 80);
    line(150 * cos(80), 147 * sin(80), 140 * cos(70), 160 * sin(70));
    line(150 * cos(80), 147 * sin(80), 120 * cos(70), 135 * sin(70));
    pop();
  }
  if (d === 13) {
    strokeWeight(0.5);
    str1 = "Theory";
    push();
    primeSpiral();
    pop();
  }
  if (d === 14) {
    strokeWeight(0.5);
    str1 = "Paradox";

    for (let j = 1; j < 5; j++) {
      push();
      scale(2 / (2 * j), 2 / (2 * j));
      dLine = width / 2;
      for (let i = 1; i < 200; i++) {
        line(
          0 - dLine / (2 * i),
          -height / 3 + i * 2,
          0 + dLine / (2 * i),
          -height / 3 + i * 2
        );
        line(
          -height / 3 + i * 2,
          0 - dLine / (2 * i),
          -height / 3 + i * 2,
          0 + dLine / (2 * i)
        );
      }
      pop();
    }
  }
  if (d === 15) {
    strokeWeight(0.5);
    str1 = "Tiling";
    n = int(random(30, 100));
    p = int(random(1, 15));
    dF = ((width / 2.2) * 2) / n;
    for (let i = 1; i < n; i++) {
      for (let j = 1; j < n; j++) {
        c = int(10 * abs(sin(i * j * p) * cos(p + i - j)));
        for (let k = 0; k < c; k += 0.2) {
          if (dF / k < dF) {
            rect(-width / 2.2 + i * dF, -width / 2.2 + j * dF, dF / k, dF / k);
          }
        }
      }
    }
  }
  if (d === 16) {
    strokeWeight(0.5);
    str1 = "Capsule";
    n = 25;
    p = int(random(5, 10));
    for (let i = 1; i <= n; i++) {
      ellipse(-200 + i * 4, 0, p, sqrt(i) * 50);
      ellipse(-200 + n * 4 + i * 4, 0, p, sqrt(n) * 50);
      ellipse(200 - n * 4 - i * 4, 0, p, sqrt(n) * 50);
      ellipse(200 - i * 4, 0, p, sqrt(i) * 50);
    }
  }
  if (d === 17) {
    strokeWeight(0.5);
    str1 = "Vault";
    n = random(150, 205);
    p = int(random(1, 4));
    s = int(random(5, 25));

    for (let i = -s; i < s; i++) {
      push();
      rotate(-s);
      ellipse((i * s) / 4, 0, n / p, n * 2);
      rotate(90);
      ellipse((i * s) / 4, 0, n / p, n * 2);
      pop();
    }
  }
  if (d === 18) {
    strokeWeight(0.5);
    str1 = "Annulus";
    n = 150;
    p = int(random(2, 20));
    q = int(random(4, 10));
    push();
    //rotate(-20)
    for (let k = 0; k < p; k++) {
      push();
      rotate((360 / p) * k);
      for (let i = 1; i < q; i++) {
        for (let j = 1; j < 2; j++) {
          rotate((360 / 20) * i);
          ellipse(i * q + q * (i - 1) + q * 3 + 20, j * q, j * 20, i * 20);
          ellipse(
            i * q + q * (i - 1) + q * 3 + 20,
            j * q,
            j * 20 + 20,
            i * 20 + 20
          );
        }
      }
      pop();
    }
  }
  if (d === 19) {
    strokeWeight(0.5);
    str1 = "Inverse";
    n = int(random(1, 1000));
    a = int(random(10, 40)); //int(random(1, 2));
    q = int(random(4, 10));
    push();
    //rotate(-20)
    for (let i = 0; i < a; i++) {
      b = random(0.1, 4);
      translate(-b, b);
      beginShape();
      for (let k = 0; k < 200; k += 0.005) {
        x = k;
        y = 1 / (k / n);

        if (y < 200) {
          vertex(x - i * b, -y + i * b);
        }
      }
      endShape();
      scale(-1, -1);
      beginShape();
      for (let k = 0; k < 200; k += 0.0005) {
        x = k;
        y = 1 / (k / n);
        if (y < 200) {
          vertex(x - i * b, -y + i * b);
        }
      }
      endShape();
    }
    pop();
  }
  if (d === 20) {
    strokeWeight(0.5);
    str1 = "Moiré";
    c1 = createVector(random(-100, 100), random(-100, 100));
    c2 = createVector(random(-100, 100), random(-100, 100));
    a = int(random(2, 8)); //int(random(1, 2));
    q = int(random(4, 10));
    push();

    for (let i = 0; i < 100; i++) {
      if (i * a < 350) {
        ellipse(0, 0, i * a, i * a);
        ellipse(c1.x, c1.y, i * a, i * a);
        ellipse(-c1.x, -c1.y, i * a, i * a);
      }
    }
    pop();
  }
  if (d === 21) {
    strokeWeight(0.5);
    str1 = "Limaçon";
    a = int(random(50, 140)); //int(random(1, 2));
    b = int(random(50, 140));
    q = int(random(10, 30));
    m = int(random(2, 9));

    for (let k = 0; k < m; k++) {
      push();
      rotate((k * 360) / m);
      for (let j = 1; j < q; j += 0.5) {
        beginShape();
        for (let i = 0; i <= 360; i++) {
          x = (1 / sqrt(j)) * (a + b * cos(i)) * cos(i);
          y = (1 / sqrt(j)) * (a + b * cos(i)) * sin(i);
          vertex(x, y);
        }
        endShape();
      }

      pop();
    }
  }
  if (d === 22) {
    strokeWeight(0.25);
    str1 = "Reciprocity";
    h = int(random(7, 32));
    p = 440 / h;
    r = p / random(1.5, 2);
    cnt = 1;
    for (let j = 0; j <= h; j++) {
      for (let k = 0; k <= h; k++) {
        push();
        translate(-225 + k * p, -225 + j * p);
        for (let i = 0; i < cnt; i++) {
          r1 = (i * i) % cnt;
          line(0, 0, r * cos((360 / cnt) * r1), r * sin((360 / cnt) * r1));
        }
        pop();
        cnt++;
      }
    }
  }
  if (d === 23) {
    strokeWeight(0.25);
    str1 = "Braid";
    h = int(random(5, 10));
    v1 = [];
    a1 = [];
    b1 = [];
    c1 = [];
    push();
    for (let k = 0; k < h; k++) {
      v1[k] = random(0.1, 1);
      a1[k] = random(0, 360);
      b1[k] = random(0.3, 3);
      c1[k] = random(1, 3);
    }

    for (let i = 0; i < 1000; i += 0.05) {
      for (let k = 0; k < h; k++) {
        push();
        translate(-200 + k * (400 / h), 0);
        noStroke();
        y = -255 + i + abs(sin(v1[k] * i - a1[k]));
        x =
          20 * b1[k] * sin(i * c1[k] + a1[k]) +
          c1[k] * 5 * cos(v1[k] * i - a1[k]) * sin(y + i * i + a1[k]);
        if (y <= 255) {
          fill(0);
          ellipse(
            x,
            y,
            1.5 - abs(sin(v1[k] * i - a1[k])),
            1.5 - abs(sin(v1[k] * i - a1[k]))
          );
        }
        pop();
      }
    }
    pop();
  }
  if (d === 24) {
    strokeWeight(0.25);
    str1 = "Antipodal";
    push();

    spacer = int(random(2, 8));
    radE = int(random(100, 150));
    orbitD = random(0, 100);
    h = int(random(10, 100));
    rotate(radE + orbitD);
    ellipse(0, 0, radE, radE);
    nodes();
    function nodes() {
      for (let i = 1; i < radE; i += spacer) {
        ellipse(0, -radE / 2 + 0.5 * i, i, i);
        ellipse(0, radE / 2 - 0.5 * i, i, i);
        sc = 1;
      }
      for (let i = 1; i < h; i += spacer / 2) {
        push();
        translate(0, -radE / 2);
        ellipse(0, -orbitD - 0.5 * i, i, i);
        pop();
        push();
        translate(0, radE / 2);
        ellipse(0, orbitD + 0.5 * i, i, i);
        pop();
      }
    }
    for (let i = 1; i < h; i += spacer / 2) {
      push();
      rotate(h - orbitD);
      translate(0, -radE);
      scale(0.5);
      rotate(spacer + h);
      nodes();
      translate(0, -radE);
      scale(0.5);
      rotate(spacer + h);
      nodes();
      pop();
      push();
      rotate(h - orbitD);
      translate(0, radE);
      scale(0.5);
      rotate(spacer + h);
      nodes();
      translate(0, radE);
      scale(0.5);
      rotate(spacer + h);
      nodes();
      pop();
    }
    pop();
  }
  if (d === 25) {
    strokeWeight(0.5);
    str1 = "Packing";
    for (let i = 0; i < int(random(3, 10)); i++) {
      push();
      p = random(0.3, 1.2);
      rotate(int(random(1, 9)) * 20);
      scale(p, p);
      gasket();
      pop();
    }
  }
  if (d === 26) {
    strokeWeight(0.5);
    str1 = "Cell";
    let sx = [];
    let sy = [];
    push();
    rotate(random(360));
    for (let i = 0; i < int(random(1, 10)); i++) {
      cell16(random(-100, 100), random(-100, 100), random(20, 120));
    }

    pop();
    function cell16(x, y, radius) {
      a3 = 360 / 8;
      cnt = 0;
      beginShape();
      for (let a = 0; a < 360; a += a3) {
        sx[cnt] = x + cos(a + random(60)) * radius * random(0.5, 1.5);
        sy[cnt] = y + sin(a + random(60)) * radius * random(0.5, 1.5);
        ellipse(sx[cnt], sy[cnt], radius / 10, radius / 10);
        vertex(sx[cnt], sy[cnt]);
        cnt++;
      }
      endShape(CLOSE);

      for (let i = 0; i < 8; i++) {
        line(sx[i], sy[i], sx[(i + 2) % 8], sy[(i + 2) % 8]);
        line(sx[i], sy[i], sx[(i + 3) % 8], sy[(i + 3) % 8]);
      }
    }
  }
  if (d === 27) {
    strokeWeight(0.5);
    str1 = "Hull";
    hull = [];
    dmax = 0;
    for (let i = 0; i < int(random(400, 1000)); i++) {
      hull[i] = createVector(
        randomGaussian(0, random(2, 50)),
        randomGaussian(0, random(20, 50))
      );
      dmax = max(dmax, dist(0, 0, hull[i].x, hull[i].y));
      ellipse(hull[i].x, hull[i].y, 2, 2);
    }
    let angle = 360 / int(random(3, 20));
    beginShape();
    for (let a = 0; a < 360; a += angle) {
      let sx = cos(a) * min(225, dmax * 1.3);
      let sy = sin(a) * min(225, dmax * 1.3);
      vertex(sx, sy);
      ellipse(sx, sy, 2, 2);
    }
    endShape(CLOSE);
  }
  if (d === 28) {
    strokeWeight(0.5);
    str1 = "Singularity";

    for (let j = 0; j < int(random(2, 22)); j++) {
      push();
      scale(0.6, 0.6);
      translate(random(-150, 150), random(-100, 100));
      for (let i = -225; i < 0; i += 0.01) {
        y = 1 / i;
        if (y < 150) {
          ellipse(i, -y, 3, 1);
          ellipse(-i, y, 3, 1);
        }
      }
      pop();
    }
  }
  if (d === 29) {
    strokeWeight(0.5);

    str1 = "Catastrophe";
    for (let j = 0; j < random(1, 300); j++) {
      push();
      translate(random(-50, 225), 0);
      g8 = random(0.01 + j / 110, j / 100);
      beginShape();
      for (let i = -200; i < 0; i += 0.01) {
        y = ((2 * i) / 3) * sqrt(abs(i) / 3);
        //ellipse(i,-0.1*y,4,4)
        if (-g8 * y < 250) {
          vertex(i, -g8 * y);
        }
      }
      endShape();
      beginShape();
      for (let i = -200; i < 0; i += 0.01) {
        y = ((2 * i) / 3) * sqrt(abs(i) / 3);
        //ellipse(i,-0.1*y,4,4)
        if (-g8 * y < 250) {
          vertex(i, g8 * y);
        }
      }
      endShape();
      pop();
    }
  }
  if (d === 30) {
    strokeWeight(0.5);
   
    str1 = "Jitter";
    for(let j = 0;j<random(1,5);j++){
      push()
      g9 = random(100,150)
      g10 = random(360)
    
    for(let i = -200;i<200;i+=2){
      y = g9*sin(i+g10)+random(0,g9/5) + g10/8*cos(i+j)
      ellipse(i,y,random(2,10),random(2,10))
     
    }
   
    pop()
    }
  }
  if (d === 31) {
    strokeWeight(0.5);
   
    str1 = "Unity";
    for(let j = 0;j<random(50,400);j++){
      push()
      g11 = random(200)
      g12 = random(j/250,3)
    beginShape()
    for(let i = 0;i<=361;i+=2){
      x = g11*cos(i)/(1+sin(i)*sin(i))
      y = g12*g11*cos(i)*sin(i)/(1+sin(i)*sin(i))
      //ellipse(x,y,random(2,10),random(2,10))
        vertex(x,y)

      
    }
    endShape()
    pop()
    }
    push()
    rotate(random(360))
    for(let j = 0;j<random(50,400);j++){
      push()
      g11 = random(200)
      g12 = random(j/250,3)
    beginShape()
    for(let i = 0;i<=361;i+=2){
      x = g11*cos(i)/(1+sin(i)*sin(i))
      y = g12*g11*cos(i)*sin(i)/(1+sin(i)*sin(i))
      //ellipse(x,y,random(2,10),random(2,10))
        vertex(x,y)

      
    }
    endShape()
    pop()
    }
    pop()
  }
  fill(0);
  stroke(0);
  scale(1, 1);
  text("Mathober Day " + d + " - " + str1, -width / 2 + 10, height / 2 - 10);
}
function mousePressed(){
  if (dayN < maxD) {
      dayN++;
    } else {
       dayN=1;
    }
    setup();
    draw();
}
function keyPressed() {
  if (keyCode === 38) {
    if (dayN < maxD) {
      dayN++;
    } else {
      dayN = 1;
    }
    setup();
    draw();
  }
  if (keyCode === 40) {
    if (dayN > 1) {
      dayN--;
    } else {
      dayN = maxD;
    }
    setup();
    draw();
  }
  if (keyCode === 32) {
    setup();
    draw();
  }
}

function polygon(x, y, radius, npoints) {
  let angle = 360 / npoints;
  beginShape();
  for (let a = 0; a < 360; a += angle) {
    let sx = x + cos(a) * radius;
    let sy = y + sin(a) * radius;
    vertex(sx, sy);
  }
  endShape(CLOSE);
}

function dissectionP() {
  beginShape();
  x = rf1 * r * sin((360 / 8) * 2 - 135 / 2);
  y = rf1 * r * cos((360 / 8) * 2 - 135 / 2);
  vertex(x, y);
  x = r * sin((360 / 8) * 1);
  y = r * cos((360 / 8) * 1);
  vertex(x, y);
  x = r * sin((360 / 8) * 2);
  y = r * cos((360 / 8) * 2);
  vertex(x, y);
  x = rf1 * r * sin((360 / 8) * 4 - 135 / 2);
  y = rf1 * r * cos((360 / 8) * 4 - 135 / 2);
  vertex(x, y);
  x = rf2 * r * sin((360 / 8) * 3);
  y = rf2 * r * cos((360 / 8) * 3);
  vertex(x, y);
  x = rf1 * r * sin((360 / 8) * 2 - 135 / 2);
  y = rf1 * r * cos((360 / 8) * 2 - 135 / 2);
  vertex(x, y);
  endShape();
}

function primeSpiral() {
  //first 14000 primes with mersenne primes highlighted
  c = 1;
  for (let i = 0; i < 14000; i++) {
    r = pow(i, 25);
    if (contains(primes, i)) {
      if (contains(mprimes, i)) {
        ellipse(log(r) * sin(i / c), log(r) * cos(i / c), 10, 10);
      }
      ellipse(log(r) * sin(i / c), log(r) * cos(i / c), 2, 2);
    }
  }
}

function contains(a, obj) {
  for (let j = 0; j < a.length; j++) {
    if (a[j] === obj) {
      return true;
    }
  }
  return false;
}

mprimes = [
  2,
  3,
  5,
  7,
  13,
  17,
  19,
  31,
  61,
  89,
  107,
  127,
  521,
  607,
  1279,
  2203,
  2281,
  3217,
  4253,
  4423,
  9689,
  9941,
  11213
];
primes = [
  2,
  3,
  5,
  7,
  11,
  13,
  17,
  19,
  23,
  29,
  31,
  37,
  41,
  43,
  47,
  53,
  59,
  61,
  67,
  71,
  73,
  79,
  83,
  89,
  97,
  101,
  103,
  107,
  109,
  113,
  127,
  131,
  137,
  139,
  149,
  151,
  157,
  163,
  167,
  173,
  179,
  181,
  191,
  193,
  197,
  199,
  211,
  223,
  227,
  229,
  233,
  239,
  241,
  251,
  257,
  263,
  269,
  271,
  277,
  281,
  283,
  293,
  307,
  311,
  313,
  317,
  331,
  337,
  347,
  349,
  353,
  359,
  367,
  373,
  379,
  383,
  389,
  397,
  401,
  409,
  419,
  421,
  431,
  433,
  439,
  443,
  449,
  457,
  461,
  463,
  467,
  479,
  487,
  491,
  499,
  503,
  509,
  521,
  523,
  541,
  547,
  557,
  563,
  569,
  571,
  577,
  587,
  593,
  599,
  601,
  607,
  613,
  617,
  619,
  631,
  641,
  643,
  647,
  653,
  659,
  661,
  673,
  677,
  683,
  691,
  701,
  709,
  719,
  727,
  733,
  739,
  743,
  751,
  757,
  761,
  769,
  773,
  787,
  797,
  809,
  811,
  821,
  823,
  827,
  829,
  839,
  853,
  857,
  859,
  863,
  877,
  881,
  883,
  887,
  907,
  911,
  919,
  929,
  937,
  941,
  947,
  953,
  967,
  971,
  977,
  983,
  991,
  997,
  1009,
  1013,
  1019,
  1021,
  1031,
  1033,
  1039,
  1049,
  1051,
  1061,
  1063,
  1069,
  1087,
  1091,
  1093,
  1097,
  1103,
  1109,
  1117,
  1123,
  1129,
  1151,
  1153,
  1163,
  1171,
  1181,
  1187,
  1193,
  1201,
  1213,
  1217,
  1223,
  1229,
  1231,
  1237,
  1249,
  1259,
  1277,
  1279,
  1283,
  1289,
  1291,
  1297,
  1301,
  1303,
  1307,
  1319,
  1321,
  1327,
  1361,
  1367,
  1373,
  1381,
  1399,
  1409,
  1423,
  1427,
  1429,
  1433,
  1439,
  1447,
  1451,
  1453,
  1459,
  1471,
  1481,
  1483,
  1487,
  1489,
  1493,
  1499,
  1511,
  1523,
  1531,
  1543,
  1549,
  1553,
  1559,
  1567,
  1571,
  1579,
  1583,
  1597,
  1601,
  1607,
  1609,
  1613,
  1619,
  1621,
  1627,
  1637,
  1657,
  1663,
  1667,
  1669,
  1693,
  1697,
  1699,
  1709,
  1721,
  1723,
  1733,
  1741,
  1747,
  1753,
  1759,
  1777,
  1783,
  1787,
  1789,
  1801,
  1811,
  1823,
  1831,
  1847,
  1861,
  1867,
  1871,
  1873,
  1877,
  1879,
  1889,
  1901,
  1907,
  1913,
  1931,
  1933,
  1949,
  1951,
  1973,
  1979,
  1987,
  1993,
  1997,
  1999,
  2003,
  2011,
  2017,
  2027,
  2029,
  2039,
  2053,
  2063,
  2069,
  2081,
  2083,
  2087,
  2089,
  2099,
  2111,
  2113,
  2129,
  2131,
  2137,
  2141,
  2143,
  2153,
  2161,
  2179,
  2203,
  2207,
  2213,
  2221,
  2237,
  2239,
  2243,
  2251,
  2267,
  2269,
  2273,
  2281,
  2287,
  2293,
  2297,
  2309,
  2311,
  2333,
  2339,
  2341,
  2347,
  2351,
  2357,
  2371,
  2377,
  2381,
  2383,
  2389,
  2393,
  2399,
  2411,
  2417,
  2423,
  2437,
  2441,
  2447,
  2459,
  2467,
  2473,
  2477,
  2503,
  2521,
  2531,
  2539,
  2543,
  2549,
  2551,
  2557,
  2579,
  2591,
  2593,
  2609,
  2617,
  2621,
  2633,
  2647,
  2657,
  2659,
  2663,
  2671,
  2677,
  2683,
  2687,
  2689,
  2693,
  2699,
  2707,
  2711,
  2713,
  2719,
  2729,
  2731,
  2741,
  2749,
  2753,
  2767,
  2777,
  2789,
  2791,
  2797,
  2801,
  2803,
  2819,
  2833,
  2837,
  2843,
  2851,
  2857,
  2861,
  2879,
  2887,
  2897,
  2903,
  2909,
  2917,
  2927,
  2939,
  2953,
  2957,
  2963,
  2969,
  2971,
  2999,
  3001,
  3011,
  3019,
  3023,
  3037,
  3041,
  3049,
  3061,
  3067,
  3079,
  3083,
  3089,
  3109,
  3119,
  3121,
  3137,
  3163,
  3167,
  3169,
  3181,
  3187,
  3191,
  3203,
  3209,
  3217,
  3221,
  3229,
  3251,
  3253,
  3257,
  3259,
  3271,
  3299,
  3301,
  3307,
  3313,
  3319,
  3323,
  3329,
  3331,
  3343,
  3347,
  3359,
  3361,
  3371,
  3373,
  3389,
  3391,
  3407,
  3413,
  3433,
  3449,
  3457,
  3461,
  3463,
  3467,
  3469,
  3491,
  3499,
  3511,
  3517,
  3527,
  3529,
  3533,
  3539,
  3541,
  3547,
  3557,
  3559,
  3571,
  3581,
  3583,
  3593,
  3607,
  3613,
  3617,
  3623,
  3631,
  3637,
  3643,
  3659,
  3671,
  3673,
  3677,
  3691,
  3697,
  3701,
  3709,
  3719,
  3727,
  3733,
  3739,
  3761,
  3767,
  3769,
  3779,
  3793,
  3797,
  3803,
  3821,
  3823,
  3833,
  3847,
  3851,
  3853,
  3863,
  3877,
  3881,
  3889,
  3907,
  3911,
  3917,
  3919,
  3923,
  3929,
  3931,
  3943,
  3947,
  3967,
  3989,
  4001,
  4003,
  4007,
  4013,
  4019,
  4021,
  4027,
  4049,
  4051,
  4057,
  4073,
  4079,
  4091,
  4093,
  4099,
  4111,
  4127,
  4129,
  4133,
  4139,
  4153,
  4157,
  4159,
  4177,
  4201,
  4211,
  4217,
  4219,
  4229,
  4231,
  4241,
  4243,
  4253,
  4259,
  4261,
  4271,
  4273,
  4283,
  4289,
  4297,
  4327,
  4337,
  4339,
  4349,
  4357,
  4363,
  4373,
  4391,
  4397,
  4409,
  4421,
  4423,
  4441,
  4447,
  4451,
  4457,
  4463,
  4481,
  4483,
  4493,
  4507,
  4513,
  4517,
  4519,
  4523,
  4547,
  4549,
  4561,
  4567,
  4583,
  4591,
  4597,
  4603,
  4621,
  4637,
  4639,
  4643,
  4649,
  4651,
  4657,
  4663,
  4673,
  4679,
  4691,
  4703,
  4721,
  4723,
  4729,
  4733,
  4751,
  4759,
  4783,
  4787,
  4789,
  4793,
  4799,
  4801,
  4813,
  4817,
  4831,
  4861,
  4871,
  4877,
  4889,
  4903,
  4909,
  4919,
  4931,
  4933,
  4937,
  4943,
  4951,
  4957,
  4967,
  4969,
  4973,
  4987,
  4993,
  4999,
  5003,
  5009,
  5011,
  5021,
  5023,
  5039,
  5051,
  5059,
  5077,
  5081,
  5087,
  5099,
  5101,
  5107,
  5113,
  5119,
  5147,
  5153,
  5167,
  5171,
  5179,
  5189,
  5197,
  5209,
  5227,
  5231,
  5233,
  5237,
  5261,
  5273,
  5279,
  5281,
  5297,
  5303,
  5309,
  5323,
  5333,
  5347,
  5351,
  5381,
  5387,
  5393,
  5399,
  5407,
  5413,
  5417,
  5419,
  5431,
  5437,
  5441,
  5443,
  5449,
  5471,
  5477,
  5479,
  5483,
  5501,
  5503,
  5507,
  5519,
  5521,
  5527,
  5531,
  5557,
  5563,
  5569,
  5573,
  5581,
  5591,
  5623,
  5639,
  5641,
  5647,
  5651,
  5653,
  5657,
  5659,
  5669,
  5683,
  5689,
  5693,
  5701,
  5711,
  5717,
  5737,
  5741,
  5743,
  5749,
  5779,
  5783,
  5791,
  5801,
  5807,
  5813,
  5821,
  5827,
  5839,
  5843,
  5849,
  5851,
  5857,
  5861,
  5867,
  5869,
  5879,
  5881,
  5897,
  5903,
  5923,
  5927,
  5939,
  5953,
  5981,
  5987,
  6007,
  6011,
  6029,
  6037,
  6043,
  6047,
  6053,
  6067,
  6073,
  6079,
  6089,
  6091,
  6101,
  6113,
  6121,
  6131,
  6133,
  6143,
  6151,
  6163,
  6173,
  6197,
  6199,
  6203,
  6211,
  6217,
  6221,
  6229,
  6247,
  6257,
  6263,
  6269,
  6271,
  6277,
  6287,
  6299,
  6301,
  6311,
  6317,
  6323,
  6329,
  6337,
  6343,
  6353,
  6359,
  6361,
  6367,
  6373,
  6379,
  6389,
  6397,
  6421,
  6427,
  6449,
  6451,
  6469,
  6473,
  6481,
  6491,
  6521,
  6529,
  6547,
  6551,
  6553,
  6563,
  6569,
  6571,
  6577,
  6581,
  6599,
  6607,
  6619,
  6637,
  6653,
  6659,
  6661,
  6673,
  6679,
  6689,
  6691,
  6701,
  6703,
  6709,
  6719,
  6733,
  6737,
  6761,
  6763,
  6779,
  6781,
  6791,
  6793,
  6803,
  6823,
  6827,
  6829,
  6833,
  6841,
  6857,
  6863,
  6869,
  6871,
  6883,
  6899,
  6907,
  6911,
  6917,
  6947,
  6949,
  6959,
  6961,
  6967,
  6971,
  6977,
  6983,
  6991,
  6997,
  7001,
  7013,
  7019,
  7027,
  7039,
  7043,
  7057,
  7069,
  7079,
  7103,
  7109,
  7121,
  7127,
  7129,
  7151,
  7159,
  7177,
  7187,
  7193,
  7207,
  7211,
  7213,
  7219,
  7229,
  7237,
  7243,
  7247,
  7253,
  7283,
  7297,
  7307,
  7309,
  7321,
  7331,
  7333,
  7349,
  7351,
  7369,
  7393,
  7411,
  7417,
  7433,
  7451,
  7457,
  7459,
  7477,
  7481,
  7487,
  7489,
  7499,
  7507,
  7517,
  7523,
  7529,
  7537,
  7541,
  7547,
  7549,
  7559,
  7561,
  7573,
  7577,
  7583,
  7589,
  7591,
  7603,
  7607,
  7621,
  7639,
  7643,
  7649,
  7669,
  7673,
  7681,
  7687,
  7691,
  7699,
  7703,
  7717,
  7723,
  7727,
  7741,
  7753,
  7757,
  7759,
  7789,
  7793,
  7817,
  7823,
  7829,
  7841,
  7853,
  7867,
  7873,
  7877,
  7879,
  7883,
  7901,
  7907,
  7919,
  7927,
  7933,
  7937,
  7949,
  7951,
  7963,
  7993,
  8009,
  8011,
  8017,
  8039,
  8053,
  8059,
  8069,
  8081,
  8087,
  8089,
  8093,
  8101,
  8111,
  8117,
  8123,
  8147,
  8161,
  8167,
  8171,
  8179,
  8191,
  8209,
  8219,
  8221,
  8231,
  8233,
  8237,
  8243,
  8263,
  8269,
  8273,
  8287,
  8291,
  8293,
  8297,
  8311,
  8317,
  8329,
  8353,
  8363,
  8369,
  8377,
  8387,
  8389,
  8419,
  8423,
  8429,
  8431,
  8443,
  8447,
  8461,
  8467,
  8501,
  8513,
  8521,
  8527,
  8537,
  8539,
  8543,
  8563,
  8573,
  8581,
  8597,
  8599,
  8609,
  8623,
  8627,
  8629,
  8641,
  8647,
  8663,
  8669,
  8677,
  8681,
  8689,
  8693,
  8699,
  8707,
  8713,
  8719,
  8731,
  8737,
  8741,
  8747,
  8753,
  8761,
  8779,
  8783,
  8803,
  8807,
  8819,
  8821,
  8831,
  8837,
  8839,
  8849,
  8861,
  8863,
  8867,
  8887,
  8893,
  8923,
  8929,
  8933,
  8941,
  8951,
  8963,
  8969,
  8971,
  8999,
  9001,
  9007,
  9011,
  9013,
  9029,
  9041,
  9043,
  9049,
  9059,
  9067,
  9091,
  9103,
  9109,
  9127,
  9133,
  9137,
  9151,
  9157,
  9161,
  9173,
  9181,
  9187,
  9199,
  9203,
  9209,
  9221,
  9227,
  9239,
  9241,
  9257,
  9277,
  9281,
  9283,
  9293,
  9311,
  9319,
  9323,
  9337,
  9341,
  9343,
  9349,
  9371,
  9377,
  9391,
  9397,
  9403,
  9413,
  9419,
  9421,
  9431,
  9433,
  9437,
  9439,
  9461,
  9463,
  9467,
  9473,
  9479,
  9491,
  9497,
  9511,
  9521,
  9533,
  9539,
  9547,
  9551,
  9587,
  9601,
  9613,
  9619,
  9623,
  9629,
  9631,
  9643,
  9649,
  9661,
  9677,
  9679,
  9689,
  9697,
  9719,
  9721,
  9733,
  9739,
  9743,
  9749,
  9767,
  9769,
  9781,
  9787,
  9791,
  9803,
  9811,
  9817,
  9829,
  9833,
  9839,
  9851,
  9857,
  9859,
  9871,
  9883,
  9887,
  9901,
  9907,
  9923,
  9929,
  9931,
  9941,
  9949,
  9967,
  9973,
  10007,
  10009,
  10037,
  10039,
  10061,
  10067,
  10069,
  10079,
  10091,
  10093,
  10099,
  10103,
  10111,
  10133,
  10139,
  10141,
  10151,
  10159,
  10163,
  10169,
  10177,
  10181,
  10193,
  10211,
  10223,
  10243,
  10247,
  10253,
  10259,
  10267,
  10271,
  10273,
  10289,
  10301,
  10303,
  10313,
  10321,
  10331,
  10333,
  10337,
  10343,
  10357,
  10369,
  10391,
  10399,
  10427,
  10429,
  10433,
  10453,
  10457,
  10459,
  10463,
  10477,
  10487,
  10499,
  10501,
  10513,
  10529,
  10531,
  10559,
  10567,
  10589,
  10597,
  10601,
  10607,
  10613,
  10627,
  10631,
  10639,
  10651,
  10657,
  10663,
  10667,
  10687,
  10691,
  10709,
  10711,
  10723,
  10729,
  10733,
  10739,
  10753,
  10771,
  10781,
  10789,
  10799,
  10831,
  10837,
  10847,
  10853,
  10859,
  10861,
  10867,
  10883,
  10889,
  10891,
  10903,
  10909,
  10937,
  10939,
  10949,
  10957,
  10973,
  10979,
  10987,
  10993,
  11003,
  11027,
  11047,
  11057,
  11059,
  11069,
  11071,
  11083,
  11087,
  11093,
  11113,
  11117,
  11119,
  11131,
  11149,
  11159,
  11161,
  11171,
  11173,
  11177,
  11197,
  11213,
  11239,
  11243,
  11251,
  11257,
  11261,
  11273,
  11279,
  11287,
  11299,
  11311,
  11317,
  11321,
  11329,
  11351,
  11353,
  11369,
  11383,
  11393,
  11399,
  11411,
  11423,
  11437,
  11443,
  11447,
  11467,
  11471,
  11483,
  11489,
  11491,
  11497,
  11503,
  11519,
  11527,
  11549,
  11551,
  11579,
  11587,
  11593,
  11597,
  11617,
  11621,
  11633,
  11657,
  11677,
  11681,
  11689,
  11699,
  11701,
  11717,
  11719,
  11731,
  11743,
  11777,
  11779,
  11783,
  11789,
  11801,
  11807,
  11813,
  11821,
  11827,
  11831,
  11833,
  11839,
  11863,
  11867,
  11887,
  11897,
  11903,
  11909,
  11923,
  11927,
  11933,
  11939,
  11941,
  11953,
  11959,
  11969,
  11971,
  11981,
  11987,
  12007,
  12011,
  12037,
  12041,
  12043,
  12049,
  12071,
  12073,
  12097,
  12101,
  12107,
  12109,
  12113,
  12119,
  12143,
  12149,
  12157,
  12161,
  12163,
  12197,
  12203,
  12211,
  12227,
  12239,
  12241,
  12251,
  12253,
  12263,
  12269,
  12277,
  12281,
  12289,
  12301,
  12323,
  12329,
  12343,
  12347,
  12373,
  12377,
  12379,
  12391,
  12401,
  12409,
  12413,
  12421,
  12433,
  12437,
  12451,
  12457,
  12473,
  12479,
  12487,
  12491,
  12497,
  12503,
  12511,
  12517,
  12527,
  12539,
  12541,
  12547,
  12553,
  12569,
  12577,
  12583,
  12589,
  12601,
  12611,
  12613,
  12619,
  12637,
  12641,
  12647,
  12653,
  12659,
  12671,
  12689,
  12697,
  12703,
  12713,
  12721,
  12739,
  12743,
  12757,
  12763,
  12781,
  12791,
  12799,
  12809,
  12821,
  12823,
  12829,
  12841,
  12853,
  12889,
  12893,
  12899,
  12907,
  12911,
  12917,
  12919,
  12923,
  12941,
  12953,
  12959,
  12967,
  12973,
  12979,
  12983,
  13001,
  13003,
  13007,
  13009,
  13033,
  13037,
  13043,
  13049,
  13063,
  13093,
  13099,
  13103,
  13109,
  13121,
  13127,
  13147,
  13151,
  13159,
  13163,
  13171,
  13177,
  13183,
  13187,
  13217,
  13219,
  13229,
  13241,
  13249,
  13259,
  13267,
  13291,
  13297,
  13309,
  13313,
  13327,
  13331,
  13337,
  13339,
  13367,
  13381,
  13397,
  13399,
  13411,
  13417,
  13421,
  13441,
  13451,
  13457,
  13463,
  13469,
  13477,
  13487,
  13499,
  13513,
  13523,
  13537,
  13553,
  13567,
  13577,
  13591,
  13597,
  13613,
  13619,
  13627,
  13633,
  13649,
  13669,
  13679,
  13681,
  13687,
  13691,
  13693,
  13697,
  13709,
  13711,
  13721,
  13723,
  13729,
  13751,
  13757,
  13759,
  13763,
  13781,
  13789,
  13799,
  13807
];

function gasket() {
  polygon4(0, 0, 148, 9, 101);
  push();
  rotate(((PI / 9) * 180) / PI);
  polygon4(0, 0, 182, 9, 33);
  pop();
  push();
  rotate(((PI / 9) * 180) / PI + ((PI / 27) * 180) / PI);
  polygon4(0, 0, 192, 9, 15);
  pop();
  push();
  rotate(((PI / 9) * 180) / PI - ((PI / 27) * 180) / PI);
  polygon4(0, 0, 192, 9, 15);
  pop();
  push();
  rotate(
    ((PI / 9) * 180) / PI + ((PI / 27) * 180) / PI + ((PI / 50) * 180) / PI
  );
  polygon4(0, 0, 195, 9, 10);
  pop();
  push();
  rotate(
    ((PI / 9) * 180) / PI - ((PI / 27) * 180) / PI - ((PI / 50) * 180) / PI
  );
  polygon4(0, 0, 195, 9, 10);
  pop();
  push();
  rotate(
    ((PI / 9) * 180) / PI +
      ((PI / 27) * 180) / PI +
      ((PI / 50) * 180) / PI +
      ((PI / 70) * 180) / PI
  );
  polygon4(0, 0, 197, 9, 5);
  pop();
  push();
  rotate(
    ((PI / 9) * 180) / PI -
      ((PI / 27) * 180) / PI -
      ((PI / 50) * 180) / PI -
      ((PI / 70) * 180) / PI
  );
  polygon4(0, 0, 197, 9, 5);
  pop();
  push();
  rotate(((PI / 9) * 180) / PI);
  polygon4(0, 0, 161, 9, 10);
  pop();
  push();
  rotate(((PI / 9) * 180) / PI);
  polygon4(0, 0, 80, 9, 55);
  pop();
  push();
  rotate(((PI / 9) * 180) / PI);
  polygon4(0, 0, 113, 9, 12);
  pop();
  polygon4(0, 0, 93, 9, 10);
  push();
  polygon4(0, 0, 43, 9, 30);
  //sphere(56 / 2, 20, 20);
  pop();
}

function polygon4(x, y, radius, npoints, r2) {
  let angle = TWO_PI / npoints;
  beginShape();
  for (let a = 0; a < TWO_PI; a += angle) {
    let sx = x + cos((a * 180) / PI) * radius;
    let sy = y + sin((a * 180) / PI) * radius;
    push();
    translate(sx, sy, 0);
    ellipse(
      0,
      0,
      2 * (r2 / 2 - (r2 / 3) * sin(0) * cos(sx / 1000)),
      2 * (r2 / 2 - (r2 / 3) * sin(0) * cos(sx / 1000))
    );
    pop();
  }
}

              
            
!
999px

Console