Merge branch 'eeeeeeeeeeeeeeeeeeeeeeee' into badge

2E.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3.7
+
+import sys
+
+
+if len(sys.argv) is not 3:
+    print('usage : 2E.py [input file] [output file]')
+    exit(-1)
+
+inFile = open(sys.argv[1], mode='rb')
+outFile = open(sys.argv[2], mode='w')
+
+for buffer in iter(lambda: inFile.read(1), b''):
+    binStr = bin(int(buffer.hex(), base=16))[2:].zfill(8)
+    for c in binStr:
+        if c == '1':
+            outFile.write('E')
+        elif c == '0':
+            outFile.write('e')
+        else:
+            print('error!')
+            exit(-1)
+
+
+inFile.close()
+outFile.close()

CMakeLists.txt

@@ -2,5 +2,5 @@ cmake_minimum_required (VERSION 2.6)
 project (eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee)
 message("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")
 add_executable(eeeee e.c)
-add_custom_command(TARGET eeeee POST_BUILD COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/eeeee)
+add_custom_command(TARGET eeeee POST_BUILD COMMAND ${CMAKE_CURRENT_BINARY_DIR}/eeeee)
 

E2.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3.7
+
+import sys
+import struct
+from array import *
+
+if len(sys.argv) is not 3:
+    print('usage : E2.py [input file] [output file]')
+    exit(-1)
+
+inFile = open(sys.argv[1], mode='rb')
+outFile = open(sys.argv[2], mode='wb')
+
+for buffer in iter(lambda: inFile.read(8), b''):
+    bin_array = array('B')
+    bin_str = ''
+    for c in buffer:
+        if c == ord('E'):
+            bin_str += '1'
+        elif c == ord('e'):
+            bin_str += '0'
+        else:
+            print('error!')
+            exit(-1)
+    bin_array.append(int(bin_str, base=2))
+    bin_array.tofile(outFile)
+
+inFile.close()
+outFile.close()

e.Dockerfile

@@ -0,0 +1,5 @@
+FROM busybox
+
+RUN seq 1 10000 | while read -r e; do echo -ne 'e'; done; echo e;
+
+CMD strings /dev/urandom | grep -oE 'e' | tr -d '\n'

e.aheui

@@ -0,0 +1,3 @@
+밝붇몋
+뚜벌이
+따밤툐

e.ahk

@@ -0,0 +1,2 @@
+Loop
+  MsgBox eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee `n

e.arnoldc

@@ -0,0 +1,5 @@
+IT'S SHOWTIME
+	STICK AROUND @NO PROBLEMO
+		TALK TO THE HAND "e"
+	CHILL
+YOU HAVE BEEN TERMINATED

e.asm

@@ -1,17 +1,56 @@
+; compile with:
+; $ [ny]asm -felf(32|64) -oe.o e.asm
+; $ (gcc|clang) -m(32|64) -oe e.o -nostdlib -nostartfiles
+
 section     .text
-global      _start                              
+global      _start
 
-_start:                                         
+%if __BITS__ == 32
+%define r(n) e%+n
+%define SYS_write 4
+%define rarg0 ebx
+%define rarg1 ecx
+%define rarg2 edx
+%define syscall int 0x80
+%else
+%define r(n) r%+n
+%define SYS_write 1
+%define rarg0 rdi
+%define rarg1 rsi
+%define rarg2 rdx
+default rel
+%endif
 
-	mov rax, 1
-	mov rdi, 1
-	mov rsi, msg
-	mov rdx, len
-	loop:
-	syscall
-	jmp loop                             
+; size of a Linux pipe buffer
+%define PIPE_SIZE 0x10000
+%define STDOUT_FILENO 1
 
-section     .data
+; Instead of simply storing a char in .rodata and write(2)-ing it
+; over and over again, we first fill a buffer full of e's, and *then*
+; write the entire buffer. This is much faster than the first option,
+; because we only need to issue a syscall once every 65536 bytes. (Remember
+; that doing a syscall requires the kernel to handle an interrupt etc etc etc.)
 
-msg: db "e"                 
-len: equ $ - msg                             
+_start:
+        ; allocate space for the message
+        mov r(cx), PIPE_SIZE
+        mov r(bx), r(cx) ; we'll need it later
+        sub r(sp), r(cx)
+
+        ; quick memset(3)
+        mov al, 'e'
+        mov r(di), r(sp)
+        rep stosb
+
+        ; push+pop is actually a smaller encoding than mov for ints that fit within 8 bit
+        push STDOUT_FILENO
+        pop rarg0
+        mov rarg1, r(sp)
+        mov rarg2, r(bx)
+
+.loop:
+        ; set this within the loop because the syscall's exit code is placed in r(ax)
+        push SYS_write
+        pop r(ax)
+        syscall
+        jmp short .loop

e.bf

@@ -1 +1 @@
-++++++++++[>++++++++++<-]>+.
+++++++++++[>++++++++++<-]>+[.]

e.birl

@@ -0,0 +1,4 @@
+HORA DO SHOW
+    CE QUER VER ESSA PORRA? ("e");
+    BORA CUMPADE 0;
+BIRL

e.c

@@ -1,13 +1,22 @@
 #include <stdio.h>
+#define e "e"
+#define ee int
+#define eee main
+#define eeee (
+#define eeeee )
+#define eeeeee {
+#define eeeeeee }
+#define eeeeeeee for
+#define eeeeeeeee ;
+#define eeeeeeeeee printf
+#define eeeeeeeeeee return
+#define eeeeeeeeeeee on_exit
+#define eeeeeeeeeeeee [
+#define eeeeeeeeeeeeee ]
+#define eeeeeeeeeeeeeee 0
 
-int main()
-{
-	for (;;) {
-		printf("e");
-	}
-}
-
-int on_exit()
-{
-	return 'e';
-}
+ee eee eeee eeeee eeeeee eeeeeeee eeee eeeeeeeee
+eeeeeeeee eeeee eeeeee eeeeeeeeee eeee e eeeee
+eeeeeeeee eeeeeee eeeeeee ee eeeeeeeeeeee eeee
+eeeee eeeeee eeeeeeeeeee e eeeeeeeeeeeee
+eeeeeeeeeeeeeee eeeeeeeeeeeeee eeeeeeeee eeeeeee

e.cfm

@@ -0,0 +1,5 @@
+<cfscript>
+	while(true){
+		writeOutput('e');
+	}
+</cfscript>

e.chpl

@@ -0,0 +1,9 @@
+coforall locale in Locales {
+  on locale {
+    coforall task_id in 0..#locale.maxTaskPar {
+      while( true ) {
+        write( "e" );
+      }
+    }
+  }
+}

e.coffee

@@ -0,0 +1,2 @@
+while 'e'
+  console.log 'e'

e.cs

@@ -1,16 +1,17 @@
-using System;
+using Eeeeeee = System.Console;
+using eeee = System.Boolean;
 
 namespace e
 {
     class E
     {
-        const bool e = true;
+        const eeee e = true;
         
-        static void Main(string[] args)
+        static void Main(string[] eeee)
         {
             while (e)
             {
-                Console.Write('e');
+                Eeeeeee.Write('e');
             }
         }
     }

e.el

@@ -0,0 +1 @@
+(while t (princ "e"))

e.hc

@@ -0,0 +1 @@
+while(1) Print("e");

e.hs

@@ -1,3 +1,2 @@
-import Control.Monad.Fix
-main = putStr $ fix ('e':)
+main = putStr $ cycle "e"
 

e.html.erb

@@ -0,0 +1,3 @@
+<% while "e" do %>
+  e
+<% end %>

e.io

@@ -0,0 +1 @@
+loop("e" print)

e.java

@@ -2,7 +2,7 @@ public class e {
 
 	public static void main(String[] e) {
 		while("e".equals("e")) {
-			System.out.println("e");
+			System.out.print("e");
 		}
 	}
 }

e.jsx

@@ -0,0 +1,33 @@
+import React, { Component } from 'react';
+
+class E extends Component {
+  constructor(props) {
+    super(props);
+
+    this.state = {
+      e: 0,
+    };
+
+    this.timer = this.timer.bind(this);
+  }
+
+  componentDidMount() {
+    const eId = setInterval(this.timer, 10);
+    this.setState({ eInterval: eId });
+  }
+
+  componentWillUnmount() {
+    clearInterval(this.state.eInterval);
+  }
+
+  timer() {
+    this.setState({ e: this.state.e + 1 });
+  }
+
+  render() {
+    const e = Array(this.state.e).fill(<p>e</p>);
+    return e;
+  }
+}
+
+export default E;

e.kt

@@ -1,4 +1,4 @@
-fun main(args: Array<String>) {
+fun main() {
     while (true) {
     	print("e")
     }

e.linux.arm.S

@@ -0,0 +1,36 @@
+#define SYS_write 4
+#define STDOUT 1
+#define PIPE_SIZE 0x10000
+
+.arm
+.align 4
+
+.section .text, "ax", %progbits
+
+type _start, %function
+globl _start
+_start:
+    mov r1, #PIPE_SIZE
+    
+    ldr r3, =('e'|('e'<<8)|('e'<<16)|('e'<<24))
+    mov r4, r3
+    mov r5, r3
+    mov r6, r3
+    
+.Lloop:
+    push {r3-r6}
+    sub r1, #(4*4)
+    cmp r1, #0
+    bgt .Lloop
+    
+    mov r7, #SYS_write
+    mov r1, sp
+    mov r2, #PIPE_SIZE
+
+.Lcall:
+    mov r0, #STDIN
+    swi #0
+    b .Lcall
+    
+.align 4
+.pool

e.lua

@@ -1,3 +1,3 @@
-while true do
+while e==e do
     print('e')
 end

e.mbr.asm

@@ -0,0 +1,31 @@
+bits 16
+org 0x7C00
+
+_start:
+    ; enable cursor
+    xor cx, cx
+    mov ch, 00100000b
+    mov ah, 1
+    int 0x10
+    
+    ; move cursor to top
+    xor dx, dx
+    xor bx, bx
+    inc ah
+    int 0x10
+    
+    ; print 1 char
+    mov ax, 'e'|(0x0E<<8)
+ .loop:
+    int 0x10
+    jmp short .loop
+
+END:
+    times 0x200-2-(END-_start) db 'e'
+    db 0x55,0xAA
+    
+stack:
+
+%if END-_org > 0x200-2
+%error "Not enough space!"
+%endif

e.mc

@@ -0,0 +1,10 @@
+Lei ha clacsonato
+  voglio Linux, Necchi come se fosse 2
+  voglio Bernarda, Necchi come se fosse 1
+  voglio testate, Mascetti come se fosse 101
+  stuzzica bituma, che se continui ti arrivano
+    testate a posterdati
+  e brematura anche, se Linux maggiore di Bernarda
+
+  voglio pazzofurioso, Necchi come se fosse 0
+  vaffanzum pazzofurioso!

e.ps

@@ -0,0 +1,2 @@
+%!
+{(e) print} loop

e.pub

@@ -0,0 +1 @@
+sh-rsa eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee+eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee+e/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee+eeeeeeeeee/eeeeeeeeeeeeeeeeeeeeeeee+eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/e/eeeee/eeeeeeeeeeeeeeeeeeeeeeeeeeee/eeeeeeeeeeeeeeeee+eeeeeeeeeeeeeeeeeeeeeeeeeeeee/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee+eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee+eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee+eeeee== eeeeee.eeeeee@eeeee.eee

e.py

@@ -1,7 +1,8 @@
 import sys
 
 try:
-    while True:
+    while 'e':
         sys.stdout.write('e')
-except KeyboardInterrupt:
+except KeyboardInterrupt as e:
     sys.exit('e')
+

e.q

@@ -0,0 +1 @@
+{while[1;-1 "e"]}

e.qml

@@ -0,0 +1,8 @@
+import QtQuick 2.0
+Image {
+    width: 1000; height: 1000
+    fillMode: Image.Tile
+    source: "https://raw.githubusercontent.com/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/eeeeeeeeeeeeeeeeeeeeeeee/e.png"
+    sourceSize.width: 10
+    sourceSize.height: 10
+}

e.rb

@@ -1,3 +1,3 @@
 loop do
-  puts "e"
+  print 'e'
 end

e.red

@@ -1,4 +1 @@
-Red []
-while [1][
-    print "E"
-]
+Red [] forever [prin "e"]

e.rs

@@ -12,3 +12,15 @@ fn e() -> ! {
         print!("e");
     }
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn teeeeest() {
+    e();
+    unreachable!("eeeeeeeeee?????");
+  }
+}
+

e.sm

@@ -0,0 +1 @@
+[true] whileTrue:[ Transcript show: 'e'. ].

e.smv

@@ -0,0 +1,8 @@
+MODULE e
+  VAR
+    e : { e };
+  ASSIGN
+    init(e) := e;
+    next(e) := e;
+    esac;
+  SPEC AG ( TRUE -> AF e = e)

e.sol

@@ -0,0 +1,15 @@
+pragma solidity ^0.5.0;
+
+contract EEEEEEEEEE {
+
+  mapping (address => string) meeeeeeeeeessage;
+
+  function sendMeeeeeeeeeessage(address _recipieeeeeeeeeent, string memory _meeeeeeeeeessage) public{
+    meeeeeeeeeessage[_recipieeeeeeeeeent] = _meeeeeeeeeessage;
+  }
+
+  function readMeeeeeeeeeessage() public view returns (string memory){
+    return meeeeeeeeeessage[msg.sender];
+  }
+
+}

e.sql

@@ -0,0 +1,13 @@
+CREATE DATABASE e;
+USE e;
+
+DELIMITER |
+CREATE PROCEDURE e()
+BEGIN
+    WHILE 'e' = 'e' DO
+        SELECT REPEAT("e",RAND()*100) AS e;
+    END WHILE;
+END|
+DELIMITER ;
+
+CALL e();

e.t

@@ -0,0 +1,15 @@
+terralib.nativetarget = terralib.newtarget {
+	Triple = "x86_64-pc-linux-gnu",
+	CPU = "x86-64",
+}
+
+stdio = terralib.includec("stdio.h")
+
+terra main(argc : int, argv : &rawstring)
+	while true do
+		stdio.printf("e")
+	end
+	return 0
+end
+
+main(0, nil)

e.tcl

@@ -0,0 +1,4 @@
+#!/usr/bin/tclsh
+while { true } {
+    puts -nonewline "e"                                                                                        
+}

e.vue

@@ -0,0 +1,28 @@
+<template>
+  <div class="e">
+    {{ e }}
+  </div>
+</template>
+
+<script>
+export default {
+  data () {
+    return {
+      e: 'e'
+    }
+  },
+
+  mounted () {
+    setInterval(() => {
+      this.e += 'e'
+    }, 1)
+  }
+}
+</script>
+
+<style>
+.e {
+  background: #eeeeee;
+}
+</style>
+

e_lc3.asm

@@ -0,0 +1,13 @@
+.ORIG x3000
+
+  
+loop AND R0, R0, #0
+     LEA R0, e
+     PUTS
+BRnzp loop  
+
+HALT
+
+e .STRINGZ "e"
+
+.END

e_linux_riscv64.S

@@ -0,0 +1,12 @@
+    .data
+e:  .byte 'e'
+
+    .text
+    .globl _start
+_start:
+    li a7, 64
+    la a1, e
+    li a2, 1
+l:  li a0, 1
+    ecall
+    j l

e_standalone.asm

@@ -0,0 +1,27 @@
+; Linker file:
+; ENTRY(start); SECTIONS { . = 1M; .boot : { KEEP(*(.multiboot_header)) } .text : { *(.text) } }
+; compile: nasm -i. -felf64 e_standalone.asm -o e
+
+  section .multiboot_header
+  bits 32
+header_start:
+  dd 0xe85250d6
+  dd 0
+	dd header_end - header_start
+	dd 0x100000000 - (0xe85250d6 + 0 + (header_end - header_start))
+  dw 0
+  dw 0
+  dd 8
+header_end:
+
+global start
+section .text
+bits 32
+start:
+	mov ecx, 0
+loop:
+	mov dword [0xb8000 + (ecx * 2)], (15 << 8) | (0x00000065)
+	inc ecx
+	cmp ecx, 2000
+	jne loop
+	hlt

eee.c

@@ -0,0 +1,21 @@
+#include <unistd.h>
+#define e "e"
+#define ee e e
+#define eee ee ee
+#define eeee eee eee
+#define eeeee eeee eeee
+#define eeeeee eeeee eeeee
+#define eeeeeee eeeeee eeeeee
+#define eeeeeeee eeeeeee eeeeeee
+#define eeeeeeeee eeeeeeee eeeeeeee
+#define eeeeeeeeee eeeeeeeee eeeeeeeee
+#define eeeeeeeeeee eeeeeeeeee eeeeeeeeee
+#define eeeeeeeeeeee eeeeeeeeeee eeeeeeeeeee
+#define eeeeeeeeeeeee eeeeeeeeeeee eeeeeeeeeeee
+#define eeeeeeeeeeeeee eeeeeeeeeeeee eeeeeeeeeeeee
+#define eeeeeeeeeeeeeee eeeeeeeeeeeeee eeeeeeeeeeeeee
+#define e_e_e(e, ee, eee) write(e, ee, eee)
+#define e_e() int main()
+#define e_(e) while(e)
+
+e_e() { e_(e) e_e_e(1, eeeeeeeeeeeeeee, 0x4000); }

eeeeee.py

@@ -1,10 +1,9 @@
 """EEe ee eeeee eee"""
+from itertools import repeat as eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
+eeeeeeeeeeeeeeeeeeeeeeee = any
+eeeeeeeee = map
+eeeeeeeeeeeeeeee = print
+e = 'e'
+eeeeeeeeeeeeeeeeeeeeeeee(eeeeeeeee(eeeeeeeeeeeeeeee, eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee(e)))
 
-eee = 1
-eeee = 1000000000
-ee = ['e' for e in range(eee, eeee)]
-
-for e in ee:
-    print(e)
-    
 # eeee