x86 मशीन कोड, 70 बाइट्स
60 89 d7 31 db 43 88 ce b2 fe 49 d1 e1 87 da 0f
c7 f0 24 7f 3c 22 72 f7 48 3c 79 74 f2 3c 59 74
ee aa 49 7c 1c 00 df 79 06 86 f7 42 43 eb f6 f6
c3 01 74 03 b0 0a aa 51 88 f9 b0 20 f3 aa 59 eb
cc c6 07 00 61 c3
मेरा निष्पादन योग्य कोड, असंतुष्ट:
0000003d <myheh>:
3d: 60 pusha
3e: 89 d7 mov %edx,%edi
40: 31 db xor %ebx,%ebx
42: 43 inc %ebx
43: 88 ce mov %cl,%dh
45: b2 fe mov $0xfe,%dl
47: 49 dec %ecx
48: d1 e1 shl %ecx
0000004a <myloop>:
4a: 87 da xchg %ebx,%edx
0000004c <myrand>:
4c: 0f c7 f0 rdrand %eax
4f: 24 7f and $0x7f,%al
51: 3c 22 cmp $0x22,%al
53: 72 f7 jb 4c <myrand>
55: 48 dec %eax
56: 3c 79 cmp $0x79,%al
58: 74 f2 je 4c <myrand>
5a: 3c 59 cmp $0x59,%al
5c: 74 ee je 4c <myrand>
5e: aa stos %al,%es:(%edi)
5f: 49 dec %ecx
60: 7c 1c jl 7e <mydone>
00000062 <mylab>:
62: 00 df add %bl,%bh
64: 79 06 jns 6c <myprint>
66: 86 f7 xchg %dh,%bh
68: 42 inc %edx
69: 43 inc %ebx
6a: eb f6 jmp 62 <mylab>
0000006c <myprint>:
6c: f6 c3 01 test $0x1,%bl
6f: 74 03 je 74 <myprint1>
71: b0 0a mov $0xa,%al
73: aa stos %al,%es:(%edi)
00000074 <myprint1>:
74: 51 push %ecx
75: 88 f9 mov %bh,%cl
77: b0 20 mov $0x20,%al
79: f3 aa rep stos %al,%es:(%edi)
7b: 59 pop %ecx
7c: eb cc jmp 4a <myloop>
0000007e <mydone>:
7e: c6 07 00 movb $0x0,(%edi)
81: 61 popa
82: c3 ret
यह एक फ़ंक्शन है जो एक्सएक्सएक्स में एक्स के आकार, और एडएक्स में आउटपुट बफर के लिए एक संकेतक प्राप्त करता है।
यह आउटपुट बफ़र को क्रमिक रूप से बाइट्स से भरता है। हैं 2 * n - 1पुनरावृत्तियों (उत्पादन के लिए गैर-स्पेस वर्णों की संख्या के बराबर)। प्रत्येक पुनरावृत्ति पर, यह निम्नलिखित करता है:
- एक यादृच्छिक संख्या उत्पन्न करें
- इसे सीमा में फिट करने के लिए संख्या के साथ फिडेल; यदि यह खराब है, तो वापस जाएं और नए सिरे से जनरेट करें
- यादृच्छिक चरित्र मुद्रित करें
- एक नई रेखा (प्रत्येक अन्य पुनरावृत्ति) प्रिंट करें
- रिक्त स्थान की उचित संख्या प्रिंट करें
एक यादृच्छिक संख्या से एक यादृच्छिक चरित्र में रूपांतरण उल्लेखनीय नहीं है:
myrand:
rdrand eax;
and al, 7fh;
cmp al, 22h;
jb myrand;
dec eax;
cmp al, 'y';
je myrand;
cmp al, 'Y';
je myrand;
दिलचस्प हिस्सा रिक्त स्थान की संख्या की गणना है। इसे निम्नलिखित संख्याएँ उत्पन्न करनी चाहिए (उदाहरण के लिए N = 9):
7 1
5 2
3 3
1 4
3
1 2
3 1
5 0
7
संख्या को दो अंकगणितीय प्रगति से बारी-बारी से लिया जाता है। पहला चरण -2 के साथ नीचे जाता है, और दूसरा चरण 1 के साथ ऊपर जाता है। जब पहली प्रगति -1 (एक्स के मध्य में) आती है, तो एक गड़बड़ होती है (-1 हटा दी जाती है), और फिर प्रगति की दिशा बदल जाती है।
प्रगति रजिस्टरों में जमा हो जाती है ebxऔर edx- उच्च भागों bhऔर dhवर्तमान संख्या, और कम भागों की दुकान blऔर dlकदम की दुकान। प्रगति के बीच वैकल्पिक करने के लिए, कोड रजिस्टर को स्वैप करता है xchg।
जब प्रगति -1 ( mylabलेबल के आसपास ) में आती है , तो यह दोनों रजिस्टरों को बढ़ाता है, जिससे चरणों को स्विच किया -2, 1जाता है -1, 2। इससे रजिस्टरों की भूमिका भी बदल जाती है, इसलिए यह रजिस्टरों के उच्च भागों को स्वैप करता है।
फ़ंक्शन के अंत में, यह स्ट्रिंग के अंत को इंगित करने के लिए एक शून्य बाइट संग्रहीत करता है।