Giới thiệu

Có lẽ bạn đã quen thuộc với bom zip , bom XML , v.v. Nói một cách đơn giản, chúng là những tệp nhỏ (tương đối) tạo ra sản lượng khổng lồ khi được giải thích bởi phần mềm ngây thơ. Thách thức ở đây là lạm dụng một trình biên dịch theo cùng một cách.

Thử thách

Viết một số mã nguồn chiếm 512 byte trở xuống và biên dịch thành một tệp chiếm dung lượng lớn nhất có thể. Tập tin đầu ra lớn nhất sẽ thắng!

Quy tắc

OK, vì vậy có một vài làm rõ, định nghĩa và hạn chế quan trọng;

• Đầu ra của quá trình biên dịch phải là tệp ELF , Windows Portable Executable (.exe) hoặc mã byte ảo cho JVM hoặc .Net's CLR (các loại mã byte ảo khác cũng có thể ổn nếu được yêu cầu). Cập nhật: Sản lượng .pyc / .pyo của Python cũng được tính .
• Nếu ngôn ngữ lựa chọn của bạn không thể được biên dịch trực tiếp thành một trong những định dạng đó, thì việc dịch mã theo sau là biên dịch cũng được cho phép ( Cập nhật: bạn có thể dịch mã nhiều lần, miễn là bạn không bao giờ sử dụng cùng một ngôn ngữ nhiều lần ).
• Mã nguồn của bạn có thể bao gồm nhiều tệp và thậm chí cả tệp tài nguyên, nhưng kích thước tổng của tất cả các tệp này không được vượt quá 512 byte.
• Bạn không thể sử dụng bất kỳ đầu vào nào khác ngoài (các) tệp nguồn và thư viện chuẩn của ngôn ngữ bạn chọn. Thư viện tiêu chuẩn liên kết tĩnh là OK khi được hỗ trợ. Cụ thể, không có thư viện bên thứ ba hoặc thư viện hệ điều hành.
• Nó phải có khả năng gọi trình biên dịch của bạn bằng cách sử dụng một lệnh hoặc một loạt các lệnh. Nếu bạn yêu cầu các cờ cụ thể khi biên dịch, các số này sẽ được tính vào giới hạn byte của bạn (ví dụ: nếu dòng biên dịch của bạn là gcc bomb.c -o bomb -O3 -lm, -O3 -lmphần (7 byte) sẽ được tính (lưu ý không gian hàng đầu ban đầu không được tính).
• Tiền xử lý chỉ được phép nếu chúng là một tùy chọn biên dịch chuẩn cho ngôn ngữ của bạn.
• Môi trường tùy thuộc vào bạn, nhưng vì lợi ích của việc xác minh điều này, vui lòng tuân theo các phiên bản trình biên dịch và hệ điều hành gần đây (có sẵn) (và rõ ràng chỉ định bạn đang sử dụng).
• Nó phải biên dịch mà không có lỗi (cảnh báo là OK) và sự cố trình biên dịch không được tính cho bất cứ điều gì.
• Những gì chương trình của bạn thực sự làm là không liên quan, mặc dù nó không thể là bất cứ điều gì độc hại. Nó thậm chí không phải bắt đầu.

ví dụ 1

Chương trình C

main(){return 1;}

Được biên dịch Apple LLVM version 7.0.2 (clang-700.1.81)trên OS X 10.11 (64-bit):

clang bomb.c -o bomb -pg

Tạo một tệp 9228 byte. Tổng kích thước nguồn là 17 + 3 (đối với -pg) = 20 byte, dễ dàng trong giới hạn kích thước.

Ví dụ 2

Chương trình Brainfuck:

++++++[->++++++++++++<]>.----[--<+++>]<-.+++++++..+++.[--->+<]>-----.--
-[-<+++>]<.---[--->++++<]>-.+++.------.--------.-[---<+>]<.[--->+<]>-.

Được dịch với awib đến c với:

./awib < bomb.bf > bomb.c

Sau đó được biên dịch với Apple LLVM version 7.0.2 (clang-700.1.81)trên OS X 10.11 (64-bit):

clang bomb.c

Tạo một tệp 8464 byte. Tổng đầu vào ở đây là 143 byte (vì đây @lang_clà mặc định cho awib nên không cần thêm vào tệp nguồn và không có cờ đặc biệt nào trong cả hai lệnh).

Cũng lưu ý rằng trong trường hợp này, tệp bomb.c tạm thời là 802 byte, nhưng điều này không tính đến kích thước nguồn cũng như kích thước đầu ra.

Lưu ý cuối cùng

Nếu đạt được sản lượng hơn 4GB (có lẽ nếu ai đó tìm thấy bộ tiền xử lý hoàn chỉnh), thì sự cạnh tranh sẽ dành cho nguồn nhỏ nhất tạo ra một tệp có kích thước tối thiểu (không thực tế để kiểm tra các bài nộp quá lớn) .

C, (14 + 15) = 29 byte nguồn, 17.179.875.837 (16 GB) byte thực thi

Cảm ơn @viraptor đã tắt 6 byte.

Cảm ơn @hvd đã tắt 2 byte và kích thước thực thi x4.

Điều này định nghĩa mainhàm là một mảng lớn và khởi tạo phần tử đầu tiên của nó. Điều này khiến GCC lưu trữ toàn bộ mảng trong kết quả thực thi.

Vì mảng này lớn hơn 2GB, chúng tôi cần cung cấp -mcmodel=mediumcờ cho GCC. Thêm 15 byte được bao gồm trong điểm, theo quy tắc.

main[-1u]={1};

Đừng mong đợi mã này sẽ làm bất cứ điều gì tốt đẹp khi chạy.

Biên dịch với:

gcc -mcmodel=medium cbomb.c -o cbomb

Phải mất một thời gian để tôi có thể thử nghiệm đề xuất của @ hvd - và tìm một máy có đủ nước để xử lý nó. Cuối cùng, tôi tìm thấy một máy ảo RedHat 5.6 không sản xuất cũ với RAM 10 GB, trao đổi 12 GB và / tmp được đặt thành một phân vùng cục bộ lớn. Phiên bản GCC là 4.1.2. Tổng thời gian biên dịch khoảng 27 phút.

Do tải CPU và RAM, tôi khuyên bạn không nên thực hiện việc biên dịch này trên bất kỳ máy nào liên quan đến sản xuất từ ​​xa .

C #, khoảng 1 phút để biên dịch, nhị phân đầu ra 28MB:

class X<A,B,C,D,E>{class Y:X<Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}

Thêm nhiều chữ Y sẽ tăng kích thước theo cấp số nhân.

Giải thích của Pharap theo yêu cầu của @Odomontois:

Câu trả lời này là lạm dụng các tham số thừa kế và loại để tạo đệ quy. Để hiểu những gì đang xảy ra, trước tiên, đơn giản hóa vấn đề. Hãy xem xét class X<A> { class Y : X<Y> { Y y; } }, tạo ra lớp chung X<A>, trong đó có một lớp bên trong Y. X<A>.Ykế thừa X<Y>, do đó X<A>.Ycũng có một lớp bên trong Y, đó là sau đó X<A>.Y.Y. Điều này sau đó cũng có một lớp bên trong Yvà lớp bên trong đó Ycó một lớp bên trong, Yv.v. Điều này có nghĩa là bạn có thể sử dụng .ad infinitum và độ phân giải phạm vi , và mỗi khi bạn sử dụng nó, trình biên dịch phải suy ra một mức độ khác của tham số và kiểu tham số .

Bằng cách thêm các tham số loại bổ sung, công việc mà trình biên dịch phải thực hiện ở mỗi giai đoạn được tăng thêm.

Xem xét các trường hợp sau:
Trong class X<A> { class Y : X<Y> { Y y;} }loại param Acó một loại X<A>.Y.
Trong class X<A> { class Y : X<Y> { Y.Y y;} }loại param Acó một loại X<X<A>.Y>.Y.
Trong class X<A> { class Y : X<Y> { Y.Y.Y y;} }loại param Acó một loại X<X<X<A>.Y>.Y>.Y.
Trong class X<A,B> { class Y : X<Y,Y> { Y y;} }loại param Alà X<A,B>.Yvà Blà X<A,B>.Y.
Trong class X<A> { class Y : X<Y> { Y.Y y;} }loại param Alà X<X<A,B>.Y, X<A,B>.Y>.Yvà Blà X<X<A,B>.Y, X<A,B>.Y>.Y.
Trong class X<A> { class Y : X<Y> { Y.Y.Y y;} }loại param Alà X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Yvà Blà X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Y.

Sau mô hình này, người duy nhất có thể tưởng tượng ¹ công việc trình biên dịch sẽ phải làm gì để suy ra những gì Ađể Eđược ở Y.Y.Y.Y.Y.Y.Y.Y.Ytrong định nghĩa class X<A,B,C,D,E>{class Y:X<Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}.

¹ Bạn có thể tìm ra điều đó, nhưng bạn cần rất nhiều kiên nhẫn, và intellisense sẽ không giúp bạn ra khỏi đây.

Python 3, nguồn 13 byte, 9.057.900.463 byte (8,5GiB) .pyc-file

(1<<19**8,)*2

Chỉnh sửa : Đã thay đổi mã thành phiên bản ở trên sau khi tôi nhận ra quy tắc nói rằng kích thước đầu ra vượt quá 4GiB không thành vấn đề và mã cho mã này ngắn hơn một chút; Mã trước - và quan trọng hơn là lời giải thích - có thể được tìm thấy bên dưới.

Python 3, nguồn 16 byte,> 32TB .pyc-file (nếu bạn có đủ bộ nhớ, dung lượng đĩa và sự kiên nhẫn)

(1<<19**8,)*4**7

Giải thích: Python 3 không gấp, và bạn nhận được số lớn nhanh với số mũ. Tuy nhiên, định dạng được sử dụng bởi các tệp .pyc lưu trữ độ dài của biểu diễn số nguyên bằng 4 byte và trong thực tế, giới hạn có vẻ giống hơn 2**31, vì vậy chỉ cần sử dụng số mũ để tạo một số lớn, giới hạn dường như tạo ra 2GB. tập tin pyc từ một nguồn 8 byte. ( 19**8hơi ngại 8*2**31, vì vậy 1<<19**8có biểu diễn nhị phân chỉ dưới 2GB; phép nhân với tám là vì chúng tôi muốn byte chứ không phải bit)

Tuy nhiên, các bộ dữ liệu cũng không thay đổi và nhân một bộ dữ liệu cũng được gấp lại liên tục, vì vậy chúng tôi có thể nhân đôi số lượng 2GB đó bao nhiêu lần tùy ý, ít nhất là 2**31nhiều lần. Việc 4**7đạt tới 32TB được chọn chỉ vì đó là số mũ đầu tiên tôi có thể tìm thấy đánh bại câu trả lời 16TB trước đó.

Thật không may, với bộ nhớ tôi có trên máy tính của riêng mình, tôi có thể kiểm tra điều này chỉ với số nhân là 2, tức là. (1<<19**8,)*2, đã tạo ra một tệp 8,5 GB, mà tôi hy vọng chứng minh rằng câu trả lời là thực tế (nghĩa là kích thước tệp không giới hạn ở 2 ** 32 = 4GB).

Ngoài ra, tôi không biết tại sao kích thước tệp tôi nhận được khi kiểm tra là 8,5 GB thay vì 4GB như tôi mong đợi và tệp đủ lớn để tôi không cảm thấy muốn chọc vào nó vào lúc này.

Nếu đạt được sản lượng hơn 4GB (có lẽ nếu ai đó tìm thấy bộ tiền xử lý hoàn chỉnh), thì sự cạnh tranh sẽ là nguồn nhỏ nhất tạo ra một tệp có kích thước tối thiểu (không thực tế để kiểm tra các bài nộp quá lớn) .

"Mẫu Haskell" cho phép mã Haskell được tạo tại thời điểm biên dịch bằng Haskell, và do đó là một bộ xử lý trước hoàn chỉnh.

Đây là nỗ lực của tôi, được tham số hóa bằng biểu thức số tùy ý FOO:

import Language.Haskell.TH;main=print $(ListE .replicate FOO<$>[|0|])

Phép thuật là mã bên trong "mối nối" $(...). Điều này sẽ được thực hiện tại thời điểm biên dịch, để tạo ra Haskell AST, được ghép vào AST của chương trình thay cho mối nối.

Trong trường hợp này, chúng tôi tạo một AST đơn giản đại diện cho nghĩa đen 0, chúng tôi sao chép FOOlần này để tạo một danh sách, sau đó chúng tôi sử dụng ListEtừ Language.Haskell.THmô-đun để biến danh sách AST này thành một AST lớn, đại diện cho nghĩa đen [0, 0, 0, 0, 0, ...].

Chương trình kết quả tương đương main = print [0, 0, 0, ...]với FOOsự lặp lại của 0.

Để biên dịch sang ELF:

$ ghc -XTemplateHaskell big.hs
[1 of 1] Compiling Main             ( big.hs, big.o )
Linking big ...
$ file big
big: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /nix/store/mibabdfiaznqaxqiy4bqhj3m9gaj45km-glibc-2.21/lib/ld-linux.so.2, for GNU/Linux 2.6.32, not stripped

Cái này nặng 83 byte (66 cho mã Haskell và 17 cho -XTemplateHaskellđối số), cộng với độ dài của FOO.

Chúng ta có thể tránh đối số trình biên dịch và chỉ biên dịch với ghc, nhưng chúng ta phải đặt {-# LANGUAGE TemplateHaskell#-}ở đầu, điều này làm cho mã lên tới 97 byte.

Dưới đây là một vài biểu thức ví dụ cho FOOvà kích thước của nhị phân kết quả:

FOO         FOO size    Total size    Binary size
-------------------------------------------------
(2^10)      6B          89B           1.1MB
(2^15)      6B          89B           3.6MB
(2^17)      6B          89B           12MB
(2^18)      6B          89B           23MB
(2^19)      6B          89B           44MB

Tôi đã hết RAM biên dịch với (2^20).

Chúng tôi cũng có thể tạo một danh sách vô hạn, sử dụng repeatthay vì replicate FOO, nhưng điều đó ngăn trình biên dịch tạm dừng;)

C ++, 250 + 26 = 276 byte

template<int A,int B>struct a{static const int n;};
template<int A,int B>const int a<A,B>::n=a<A-1,a<A,B-1>::n>::n;
template<int A>struct a<A,0>{static const int n=a<A-1,1>::n;};
template<int B>struct a<0,B>{static const int n=B+1;};
int h=a<4,2>::n;

Đây là chức năng Ackermann được triển khai trong các mẫu. Tôi không thể biên dịch h=a<4,2>::n;trên máy nhỏ (6GB) của mình, nhưng tôi đã quản lý h=a<3,14>tệp đầu ra 26M. Bạn có thể điều chỉnh các hằng số để đạt giới hạn của nền tảng của mình - xem bài viết Wikipedia được liên kết để được hướng dẫn.

Yêu cầu -ggắn cờ với GCC (vì đó là tất cả các biểu tượng gỡ lỗi thực sự tiêu tốn bất kỳ khoảng trống nào) và độ sâu mẫu lớn hơn mặc định. Dòng biên dịch của tôi đã kết thúc như

g++ -ftemplate-depth=999999 -g -c -o 69189.o 69189.cpp

Thông tin nền tảng

g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2
Linux 3.13.0-46-generic #79-Ubuntu SMP x86_64 GNU/Linux

ASM, 61 byte (nguồn 29 byte, 32 byte cho cờ), 4.294.975.320 byte thực thi

.globl main
main:
.zero 1<<32

Biên dịch với gcc the_file.s -mcmodel=large -Wl,-fuse-ld=gold

Đây là câu trả lời C của tôi từ năm 2005. Sẽ tạo ra nhị phân 16TB nếu bạn có 16TB RAM (bạn không).

struct indblock{
   uint32_t blocks[4096];
};

struct dindblock {
    struct indblock blocks[4096];
};

struct tindblock {
    struct dindblock blocks[4096];
};

struct inode {
    char data[52]; /* not bothering to retype the details */
    struct indblock ind;
    struct dindblock dint;
    struct tindblock tind;
};

struct inode bbtinode;

int main(){}

Bộ tiền xử lý C cũ: đầu vào 214 byte, đầu ra 5 MB

Lấy cảm hứng từ bộ tiền xử lý trong thế giới thực của tôi thất bại ở đây .

#define A B+B+B+B+B+B+B+B+B+B
#define B C+C+C+C+C+C+C+C+C+C
#define C D+D+D+D+D+D+D+D+D+D
#define D E+E+E+E+E+E+E+E+E+E
#define E F+F+F+F+F+F+F+F+F+F
#define F x+x+x+x+x+x+x+x+x+x

int main(void) { int x, y = A; }

Các thí nghiệm cho thấy rằng mỗi cấp độ của #defineý chí (như mong đợi) làm cho sản lượng lớn hơn khoảng mười lần. Nhưng vì ví dụ này mất hơn một giờ để biên dịch, tôi không bao giờ tiếp tục "G".

Java, nguồn 450 + 22 = 472 byte, tệp lớp ~ 1GB

B.java (phiên bản golf, cảnh báo trong quá trình biên dịch)

import javax.annotation.processing.*;@SupportedAnnotationTypes("java.lang.Override")public class B extends AbstractProcessor{@Override public boolean process(java.util.Set a,RoundEnvironment r){if(a.size()>0){try(java.io.Writer w=processingEnv.getFiler().createSourceFile("C").openWriter()){w.write("class C{int ");for(int i=0;i<16380;++i){for(int j=0;j<65500;++j){w.write("i");}w.write(i+";int ");}w.write("i;}");}catch(Exception e){}}return true;}}

B.java (phiên bản chưa được chỉnh sửa)

import java.io.Writer;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;

@SupportedAnnotationTypes("java.lang.Override")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class B extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (annotations.size() > 0) {
            try (Writer writer = processingEnv.getFiler().createSourceFile("C").openWriter()) {
                writer.write("class C{int ");
                for (int i = 0; i < 16380; ++i) {
                    for (int j = 0; j < 65500; ++j) {
                        writer.write("i");
                    }
                    writer.write(i + ";int ");
                }
                writer.write("i;}");
            } catch (Exception e) {
            }
        }
        return true;
    }
}

Biên soạn

javac B.java
javac -J-Xmx16G -processor B B.java

Giải trình

Bom này sử dụng Bộ xử lý chú thích. Nó cần 2 lượt biên dịch. Pass đầu tiên xây dựng lớp bộ xử lý B. Trong lần truyền thứ hai, bộ xử lý tạo một tệp nguồn mới C.javavà biên dịch nó thành một tệp C.classcó kích thước 1,073,141,162byte.

Có một số hạn chế khi cố gắng tạo một tệp lớp lớn:

• Tạo định danh dài hơn khoảng 64k kết quả trong : error: UTF8 representation for string "iiiiiiiiiiiiiiiiiiii..." is too long for the constant pool.
• Tạo nhiều hơn khoảng 64k biến / hàm cho kết quả: error: too many constants
• Ngoài ra còn có giới hạn khoảng 64k cho kích thước mã của hàm.
• Dường như có một giới hạn chung (lỗi?) Trong trình biên dịch java khoảng 1GB cho .classtệp. Nếu tôi tăng 16380lên 16390trong đoạn mã trên, trình biên dịch không bao giờ trả về.
• Ngoài ra còn có giới hạn khoảng 1GB cho .javatệp. Tăng 16380lên 16400trong mã trên dẫn đến: An exception has occurred in the compiler (1.8.0_66). Please file a bug ...theo sau là a java.lang.IllegalArgumentException.

C, nguồn 26 byte, đầu ra 2.139.103.367 byte, chương trình hợp lệ

const main[255<<21]={195};

Được biên dịch bằng: gcc cbomb.c -o cbomb(gcc phiên bản 4.6.3, Ubuntu 12.04, ~ 77 giây)

Tôi nghĩ tôi sẽ thử xem tôi có thể tạo ra một chương trình hợp lệ lớn đến mức nào mà không cần sử dụng bất kỳ tùy chọn dòng lệnh nào. Tôi đã có ý tưởng từ câu trả lời này: https://codegolf.stackexchange.com/a/69193/44946 bởi Digital Trauma. Xem các ý kiến ​​ở đó là lý do tại sao điều này biên dịch.

Cách thức hoạt động: Việc constxóa cờ ghi khỏi các trang trong phân đoạn, vì vậy chính có thể được thực thi. Đây 195là mã máy Intel để trả lại. Và vì kiến ​​trúc Intel là ít endian, đây là byte đầu tiên. Chương trình sẽ thoát với bất kỳ mã khởi động nào được đặt trong thanh ghi eax, có thể là 0.

Nó chỉ có khoảng 2 gig vì trình liên kết đang sử dụng các giá trị được ký 32 bit cho các offset. Đó là 8 meg nhỏ hơn 2 gig vì trình biên dịch / trình liên kết cần một số không gian để hoạt động và đây là phần lớn nhất tôi có thể nhận được mà không có lỗi liên kết - ymmv.

Boo , 71 byte. Thời gian biên dịch: 9 phút. Thực thi 134.222.236 byte

macro R(e as int):
 for i in range(2**e):yield R.Body
x = 0
R 25:++x

Sử dụng một macro R(cho Lặp lại) để làm cho trình biên dịch nhân số câu lệnh tăng lên một số lần tùy ý. Không có cờ biên dịch đặc biệt là cần thiết; chỉ cần lưu tệp dưới dạng bomb.boovà gọi trình biên dịch booc bomb.boođể xây dựng nó.

Kotlin , nguồn 90 byte, 177416 byte (173 KB) được biên dịch nhị phân JVM

inline fun a(x:(Int)->Any){x(0);x(1)}
fun b()=a{a{a{a{a{a{a{a{a{a{a{println(it)}}}}}}}}}}}

Về mặt kỹ thuật, bạn có thể làm điều này lâu hơn nữa bằng cách lồng biểu thức xa hơn. Tuy nhiên, trình biên dịch gặp sự cố StackOverflownếu bạn tăng đệ quy.

C ++, 214 byte (không cần tùy chọn biên dịch đặc biệt)

#define Z struct X
#define T template<int N
T,int M=N>Z;struct Y{static int f(){return 0;}};T>Z<N,0>:Y{};T>Z<0,N>:Y{};T,int M>Z{static int f(){static int x[99999]={X<N-1,M>::f()+X<N,M-1>::f()};}};int x=X<80>::f();

Đây là một đệ quy mẫu hai chiều khá đơn giản (độ sâu đệ quy đi theo căn bậc hai của tổng số mẫu được phát ra, do đó sẽ không vượt quá giới hạn nền tảng), với một lượng nhỏ dữ liệu tĩnh trong mỗi một.

Tệp đối tượng được tạo với g++ 4.9.3 x86_64-pc-cygwin2567355421 byte (2.4GiB).

Việc tăng giá trị ban đầu trên 80 sẽ phá vỡ trình biên dịch gg cygwin (quá nhiều phân đoạn).

Ngoài ra, 99999có thể được thay thế bằng 9<<19hoặc tương tự để tăng kích thước mà không thay đổi mã nguồn ... nhưng tôi không nghĩ mình cần sử dụng nhiều dung lượng đĩa hơn mức tôi đã có;)

Scala - nguồn 70 byte, kết quả 22980942 byte (sau jar)

import scala.{specialized => s}
class X[@s A, @s B, @s C, @s D, @s E]

Điều này tạo ra 9 ⁵ (khoảng 59.000) tệp lớp chuyên biệt, đóng gói vào một hũ khoảng 23 MB. Về nguyên tắc, bạn có thể tiếp tục nếu bạn có một hệ thống tệp có thể xử lý nhiều tệp đó và đủ bộ nhớ.

(Nếu phải bao gồm lệnh jar, thì đó là 82 byte.)

C, 284 byte + 2 cho -cin gcc bomb.c -o bomb.o -c; đầu ra: 2 147 484 052 byte

#define a 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
#define b a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a
#define c b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b
#define d c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c
#define e d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d
#define f e,e,e,e,e,e,e,e,e,e,e,e,e,e,e,e
__int128 x[]={f,f,f,f,f,f,f,f};

Boo, cách nhiều hơn bạn có thể mong đợi từ điều này

macro R(e as int):for i in range(9**e):yield R.Body
x = 0
R 99:++x

Con trăn 3:

9**9**9**9**9

Bom Tết