🎾 🎼 💔 लिनक्स के लिए 1k / 4k इंट्रो बनाना, भाग 1 👩🏽‍⚕️ 🏴󠁧󠁢󠁷󠁬󠁳󠁿 🤚🏼

"रूसी मंच पर, हम सब पर कुछ करके एक-दूसरे को आश्चर्यचकित करते हैं," © मने
(लोकतांत्रिक स्थिति पर SCRIMERS की स्थिति /forum से)

पांच मिनट की मेटा: इस पाठ में, आप, बिल्ली के बच्चे, इस बारे में पढ़ेंगे कि अपना समय कैसे व्यतीत करना है, परिणामी उत्पाद के आकार के अनुपात और खर्च किए गए समय के संदर्भ में पूरी तरह से अप्रभावी है।
मान लीजिए कि हम 4kb में इंट्रो के समान कुछ करना चाहते हैं, लेकिन हम दुष्ट हैं और हमारे पास विंडोज़ के लिए पैसे नहीं हैं और शाॅर्ड के साथ एक वीडियो कार्ड है जो ब्रांचिंग का समर्थन करता है। या हम सिर्फ apack / crinkler / sonant / 4klang / god-what-there-still-have से मानक सेट नहीं लेना चाहते हैं, अगले एक "यह सब देखें! मैं भी, दूरी के खेतों को फिर से मार्च करने में सक्षम हूँ! ”और दसियों या सैकड़ों एक ही लोगों के बीच खो जाते हैं । खैर, या हम सिर्फ किसी भी तरह दिखावा करना पसंद करते हैं, उम्मीद करते हैं कि लड़कियां आखिरकार हमारी ओर ध्यान देंगी।

सामान्य तौर पर, यह महत्वपूर्ण नहीं है। मान लीजिए कि हमारे पास कमजोर ग्राफिक्स कार्ड के साथ बस किसी प्रकार का लिनक्स है और हमारे सभी युवा आगे हैं। अब इन सभी के साथ एक स्टार्टअप फ़ाइल बनाने की कोशिश करते हैं, जिसका आकार 1024 बाइट्स से अधिक नहीं है, जो स्टार्टअप पर किसी भी तरह उपयोगकर्ता को बनाने और दिखाने के लिए प्रबंधित करेगा।

इसके लिए हम क्या उपयोग कर सकते हैं? सबसे पहले, हमारे पास X11 और OpenGL हैं। उन्हें कम से कम रक्त से कैसे आरंभ किया जा सकता है:

सीधे Xlib, GLX के माध्यम से
+: यह सिस्टम में गारंटी है;
- - 11 कॉल सिर्फ जीएल संदर्भ को बढ़ाने के लिए
भरमार
+: जीएल संदर्भ के लिए 4-5 कार्य;
- - हर जगह से बहुत दूर
एसडीएल
+: संदर्भ के लिए 2 कॉल, वास्तविक मानक, लगभग हर जगह हैं;
- - यह अचानक कहीं नहीं हो सकता है, या भविष्य में नए संस्करणों के साथ कुछ अनुकूलता संभावित रूप से क्रॉल कर सकती है
पुस्तकालयों पर हथौड़ा मारें और अपने हाथों से सब कुछ करें
+: आप डायनामिक लिंक को बाहर निकाल सकते हैं और अफवाहों (viznut?) के अनुसार प्राप्त कर सकते हैं, CL संदर्भ को आरंभ करने के लिए लगभग 300 बाइट्स
- - जब तक आप इसका पता नहीं लगा लेते तब तक आप खुद ही सब कुछ तोड़ सकते हैं

बाद का विकल्प निस्संदेह सबसे कठिन है, लेकिन यह मेरे लिए अब तक बहुत जटिल है। इसलिए, हम तपस्या करेंगे।

आइए gcc को उजागर करें और हर उस चीज़ को महसूस करने की कोशिश करें, जिससे हमें निपटना है। आइए हमारे इंट्रा के कंकाल के साथ शुरू करें - ओपनजीएल संदर्भ को इनिशियलाइज़ करें, व्यूपोर्ट को इंगित करें और एक सरल ईवेंटलूप चलाएं जो किसी भी कुंजी को दबाए जाने पर एप्लिकेशन को समाप्त कर देता है:

#include <SDL.h> #define W 1280 #define H 720 #define FULLSCREEN 0//SDL_FULLSCREEN int main(int argc, char* argv) { SDL_Init(SDL_INIT_VIDEO); SDL_SetVideoMode(W, H, 32, SDL_OPENGL | FULLSCREEN); glViewport(0, 0, W, H); SDL_Event e; for(;;) { SDL_PollEvent(&e); if (e.type == SDL_KEYDOWN) break; // -    SDL_GL_SwapBuffers(); } SDL_Quit(); return 0; }

(यहाँ एक चौकस पाठक निम्नलिखित मिल सकता है:

सूरज से बाहर आशावाद - त्रुटियों के लिए जाँच का पूर्ण अभाव
e.type == SDL_QUIT (किसी उपयोगकर्ता द्वारा विंडो बंद करने के लिए प्रसंस्करण) के लिए जाँच की कमी, जो क्रॉस पर क्लिक करके अनुप्रयोगों को बंद करने के प्रशंसकों को थोड़ा परेशान करेगा, न कि एक मनमानी कुंजी दबाकर

मैं जवाब दूंगा: क्या यह अभी भी होगा! "

इसे संकलित करें:

(नोट 1: बाइनरी डिस्ट्रीब्यूशन के उपयोगकर्ताओं के लिए: आपको एक कंपाइलर (जीसीसी), ओपनजीएल के लिए हेडर फाइलें (आमतौर पर मीसा में) और डेवलपर्स के लिए एक एसडीएल संस्करण (libsdl-dev, या ऐसा ही कुछ) चाहिए।)
(Note2: -m32 ध्वज केवल 64-बिट वितरण के मालिकों के लिए आवश्यक है)

 cc -m32 -o intro intro.c `pkg-config --libs --cflags sdl` -lGL

और हम भयभीत होंगे कि इतना सरल कार्यक्रम लगभग 7kb लेता है!

हम शलजम को काटते हैं, हम समझते हैं कि crt और अन्य बुर्जुआ ज्यादतियों ने अंजीर को नहीं छोड़ा, इसलिए हमने उन्हें काट दिया।
आवश्यक:

मुख्य () के बजाय, तर्क और वापसी मूल्य के बिना _start () फ़ंक्शन की घोषणा करें (क्या इसका नाम बदला जा सकता है, लेकिन क्यों?)।
केवल इस फ़ंक्शन से बाहर निकलने के बजाय, एप्लिकेशन से बाहर निकलने के लिए एक सिस्टम कॉल करें (eax = 1, ebx = exit_code)।

 #include <SDL.h> #define W 1280 #define H 720 #define FULLSCREEN 0//SDL_FULLSCREEN void _start() { SDL_Init(SDL_INIT_VIDEO); SDL_SetVideoMode(W, H, 32, SDL_OPENGL | FULLSCREEN); glViewport(0, 0, W, H); SDL_Event e; for(;;) { SDL_PollEvent(&e); if (e.type == SDL_KEYDOWN) break; // -    SDL_GL_SwapBuffers(); } SDL_Quit(); asm ( \ "xor %eax,%eax\n" \ "inc %eax\n" \ "int $0x80\n" \ ); }

इसके अलावा, आपको जीसीसी विकल्प -nostartfiles निर्दिष्ट करना होगा।
और एक ही समय में तुरंत बाइनरी पट्टी:

 cc -m32 -o intro intro.c `pkg-config --libs --cflags sdl` -lGL -Os -s -nostartfiles

हमें ~ 4.7 किलोबाइट मिलते हैं, जो कि ~ 30% बेहतर है, लेकिन फिर भी बहुत कुछ है।
उपयोगी कोड के इस कार्यक्रम में, बिल्ली भी रोई, और लगभग सभी जगह पर विभिन्न योगिनी-हेडर का कब्जा है। हेडर से बेकारता को काटने के लिए, एल्फिकर्स सेट (http://www.muppetlabs.com/~breadbox/software/elfkickers.html) से एक sstrip उपयोगिता है:

 sstrip intro

यह हमें लगभग 600 और बाइट्स देता है और खतरनाक रूप से बाइनरी का आकार 4kb तक लाता है। और वह अभी भी कुछ भी उपयोगी नहीं है।

एक बार फिर हम परेशान हैं, हम हेक्स संपादक में अपने बाइनरी को देखते हैं और शून्य पाते हैं। उनमें से बहुत सारे। और शून्य और अन्य पहचान से लड़ने में सबसे अच्छा कौन है?
सही:

 cat intro | 7z a dummy -tGZip -mx=9 -si -so > intro.gz

(नोट 1-स्पष्टता: आपको p7zip पैकेज स्थापित करने की आवश्यकता है। p7zip इतना जटिल क्यों है? क्योंकि: (a) gzip और अन्य कुछ प्रतिशत खराब कर देते हैं, (b) आपको फ़ाइल नाम की तरह, अतिरिक्त मेटाडेटा से gz-हैडर को हटाने की आवश्यकता होती है)
(नोट 2: सामान्य रूप से gzip क्यों है, और नहीं, बोलो, bzip2! क्योंकि आनुभविक रूप से p7zip -tGZip मेरे द्वारा आजमाई गई हर चीज से सबसे अच्छा परिणाम देता है, और जिसके अनपैक हर जगह कम या ज्यादा होते हैं।
intro.gz पहले से ही लगभग 650 बाइट्स लेता है! यह केवल इसे चलाने के लिए बनी हुई है। निम्नलिखित सामग्री के साथ एक unpack_header फ़ाइल बनाएँ:

 T=/tmp/i;tail -n+2 $0|zcat>$T;chmod +x $T;$T;rm $T;exit

और इस शीर्ष लेख को हमारे संग्रह में चिपकाएँ:

 cat unpack_header intro.gz > intro.sh

चलिए फ़ाइल को निष्पादन योग्य बनाते हैं और जो हमें मिला उसे देखते हैं:

 chmod +x intro.sh ./intro.sh

सुनिश्चित करें कि पेनी बाइट के साथ ये 700 वास्तव में एक खाली खिड़की बनाते हैं।
जो हमने अभी किया है उसे गज़िप-ड्रॉपिंग कहा जाता है, और इसकी जड़ें कैब-ड्रॉपिंग विधि पर वापस जाती हैं, जो अपने समय में लोकप्रिय थी (क्रिंकलर और दोस्तों के युग से पहले), जो बिल्कुल वैसा ही काम करती थी, लेकिन विंडोज के तहत।

आइए देखें कि शेष 300 बाइट्स के लिए कितना आरक्षित किया जा सकता है। परंपरागत रूप से, हम निम्न कार्य करते हैं: संपूर्ण स्क्रीन पर glRect प्रदर्शित करते हैं, जो प्रपत्र रंग = f (x, y) के विशेष शेड द्वारा खींचा जाता है:

 #include <SDL.h> #include <GL/gl.h> #define W 1280 #define H 720 #define FULLSCREEN 0//SDL_FULLSCREEN char* shader_vtx[] = { "varying vec4 p;" "void main(){gl_Position=p=gl_Vertex;}" }; char* shader_frg[] = { "varying vec4 p;" "void main(){" "gl_FragColor=p;" "}" }; void shader(char** src, int type, int p) { int s = glCreateShader(type); glShaderSource(s, 1, src, 0); glCompileShader(s); glAttachShader(p, s); } void _start() { SDL_Init(SDL_INIT_VIDEO); SDL_SetVideoMode(W, H, 32, SDL_OPENGL | FULLSCREEN); glViewport(0, 0, W, H); int p = glCreateProgram(); shader(shader_vtx, GL_VERTEX_SHADER, p); shader(shader_frg, GL_FRAGMENT_SHADER, p); glLinkProgram(p); glUseProgram(p); SDL_Event e; for(;;) { SDL_PollEvent(&e); if (e.type == SDL_KEYDOWN) break; glRecti(-1,-1,1,1); SDL_GL_SwapBuffers(); } SDL_Quit(); asm ( \ "xor %eax,%eax\n" \ "inc %eax\n" \ "int $0x80\n" \ ); }

कोड काफी पारदर्शी है, सिवाय, शायद, अलग-अलग vec4 पी के साथ, जो सामान्य स्क्रीन के निर्देशांक को वर्टिशर shader से टुकड़ा एक तक खींचने के लिए कार्य करता है और हमें विंडो के भौतिक आकार से स्वतंत्र बनाता है।

तो, चलो इकट्ठा करने की कोशिश करते हैं:

 cc -m32 -o intro intro.c `pkg-config --libs --cflags sdl` -lGL -Os -s -nostartfiles && \ sstrip intro && \ cat intro | 7z a dummy -tGZip -mx=9 -si -so > intro.gz && \ cat unpack_header intro.gz > intro.sh && chmod +x intro.sh && \ wc -c intro.sh && \ ./intro.sh

हम पाते हैं कि इस तरह की तिपहिया के साथ हम पहले से ही अतिरिक्त 50 बाइट पकड़ चुके हैं, और अनुमत एक किलोबाइट के लिए क्रॉल किया गया है। "तुम अब भी मेरे साथ नाचोगे, तुम नाचोगे!", हम सोचते हैं, और हमें अपने बॉस से आखिरी चाल मिलती है: गतिशील पुस्तकालयों से सभी आवश्यक कार्यों को मैन्युअल रूप से लोड करना:

 #include <dlfcn.h> #include <SDL.h> #include <GL/gl.h> #define W 1280 #define H 720 #define FULLSCREEN 0//SDL_FULLSCREEN const char* shader_vtx[] = { "varying vec4 p;" "void main(){gl_Position=p=gl_Vertex;}" }; const char* shader_frg[] = { "varying vec4 p;" "void main(){" "gl_FragColor=p;" "}" }; const char dl_nm[] = "libSDL-1.2.so.0\0" "SDL_Init\0" "SDL_SetVideoMode\0" "SDL_PollEvent\0" "SDL_GL_SwapBuffers\0" "SDL_Quit\0" "\0" "libGL.so.1\0" "glViewport\0" "glCreateProgram\0" "glLinkProgram\0" "glUseProgram\0" "glCreateShader\0" "glShaderSource\0" "glCompileShader\0" "glAttachShader\0" "glRecti\0\0\0"; // : #define _SDL_Init ((void(*)(int))dl_ptr[0]) #define _SDL_SetVideoMode ((void(*)(int,int,int,int))dl_ptr[1]) #define _SDL_PollEvent ((void(*)(void*))dl_ptr[2]) #define _SDL_GL_SwapBuffers ((void(*)())dl_ptr[3]) #define _SDL_Quit ((void(*)())dl_ptr[4]) #define _glViewport ((void(*)(int,int,int,int))dl_ptr[5]) #define _glCreateProgram ((int(*)())dl_ptr[6]) #define _glLinkProgram ((void(*)(int))dl_ptr[7]) #define _glUseProgram ((void(*)(int))dl_ptr[8]) #define _glCreateShader ((int(*)(int))dl_ptr[9]) #define _glShaderSource ((void(*)(int,int,const char**,int))dl_ptr[10]) #define _glCompileShader ((void(*)(int))dl_ptr[11]) #define _glAttachShader ((void(*)(int,int))dl_ptr[12]) #define _glRecti ((void(*)(int,int,int,int))dl_ptr[13]) void* dl_ptr[14]; //  -    void dl() { const char* pn = dl_nm; void** pp = dl_ptr; for(;;) //    { void* f = dlopen(pn, RTLD_LAZY); //  for(;;) //    precious  { while(*(pn++) != 0); //         if (*pn == 0) break; //    ,     so' *pp++ = dlsym(f, pn); } //     if (*++pn == 0) break; //   -  ,  ,   } } void shader(const char** src, int type, int p) { int s = _glCreateShader(type); _glShaderSource(s, 1, src, 0); _glCompileShader(s); _glAttachShader(p, s); } void _start() { dl(); _SDL_Init(SDL_INIT_VIDEO); _SDL_SetVideoMode(W, H, 32, SDL_OPENGL | FULLSCREEN); _glViewport(0, 0, W, H); int p = _glCreateProgram(); shader(shader_vtx, GL_VERTEX_SHADER, p); shader(shader_frg, GL_FRAGMENT_SHADER, p); _glLinkProgram(p); _glUseProgram(p); SDL_Event e; for(;;) { _SDL_PollEvent(&e); if (e.type == SDL_KEYDOWN) break; _glRecti(-1,-1,1,1); _SDL_GL_SwapBuffers(); } _SDL_Quit(); asm ( \ "xor %eax,%eax\n" \ "inc %eax\n" \ "int $0x80\n" \ ); }

वाह! अंत में, यह कम या ज्यादा मांसल और भ्रमित हो जाता है!
यहां क्या होता है: हम पुस्तकालयों और कार्यों को शून्य विभाजकों के माध्यम से एक पंक्ति में उनकी आवश्यकता के बजाय संग्रहीत करते हैं, यह सब डेटा एल्फ हेडर के अंदर बहुत ढीले और खराब पैक संरचनाओं में संग्रहीत करने के बजाय। स्ट्रिंग से कार्य केवल पॉइंटर्स के एक सरणी में लोड किए जाते हैं, जिससे उन्हें पहले से ही सही समय पर मैक्रोज़ के माध्यम से बुलाया जाता है। यह ध्यान देने योग्य है कि विशिष्ट प्रकार के पैरामीटर उचित सीमा तक मायने नहीं रखते हैं - वे अभी भी स्टैक पर 4 बाइट्स द्वारा संरेखित किए जाएंगे। और वापसी मूल्य को सामान्य रूप से नजरअंदाज किया जा सकता है यदि इसकी आवश्यकता नहीं है - वैसे भी, सम्मेलन द्वारा, कॉलिंग फ़ंक्शन, eax को सहेजने की उम्मीद नहीं करता है। और इससे भी अधिक, आपको त्रुटियों की जांच करने की आवश्यकता नहीं है - केवल स्लोब और लत्ता है जो कोई भी नहीं देता है त्रुटियों के लिए जाँच की जाती है।
बिल्ड टीम में, हम बाइनरी को लक्ष्य तक स्ट्रिप करेंगे, इसे केवल ld-linux.so पर निर्भरता के साथ छोड़कर (एक इंटरप्रेटर जो सामान्य रूप से डायनेमिक लिंकिंग की अनुमति देता है), और libld.so, जिसमें dlben और dlsym फ़ंक्शन शामिल हैं:

 cc -Wall -m32 -c intro.c `pkg-config --cflags sdl` -Os -nostartfiles && \ ld -melf_i386 -dynamic-linker /lib32/ld-linux.so.2 -ldl intro.o -o intro && \ sstrip intro && \ cat intro | 7z a dummy -tGZip -mx=9 -si -so > intro.gz && \ cat unpack_header intro.gz > intro.sh && chmod +x intro.sh && \ wc -c intro.sh && \ ./intro.sh

899 बाइट्स! वसा बाइट्स के साथ एक सौ अधिक क्रिएटिविटी ™ के साथ स्कोर किया जा सकता है!

आप वहां क्या फिट कर सकते हैं? उदाहरण के लिए, पुरानी सुरंग प्रभाव, जिसमें से हर कोई पहले से ही बीमार है (हाँ, ऊपर स्क्रीनशॉट से एक है)।
पहले हमें समय को छाया में खींचने की जरूरत है। हम gluniform के माध्यम से nerds की तरह यह नहीं करेंगे, लेकिन इसे एक साधारण तरीके से करेंगे, जैसे कि यार्ड लड़के:

 float t = _SDL_GetTicks() / 1000. + 1.; _glRectf(-t, -t, t, t);

प्रक्षेप में समय न गंवाने के लिए, हमें शीर्षासन करने वाले से थोड़ी मदद चाहिए:

 const char* shader_vtx[] = { "varying vec4 p;" "void main(){gl_Position=p=gl_Vertex;pz=length(p.xy);}" };

यही है, अब pz घटक में हमारे पास वर्तमान समय है। यह केवल इसे सुरंग में संलग्न करने के लिए बनी हुई है।
सुरंग बस किया जाता है - हमारे पास एक कोण है = अतन (px, py) और एक देहाती परिप्रेक्ष्य: z = 1. / लंबाई (p.xy), यह केवल कुछ बनावट का रंग उत्पन्न करने के लिए बना रहता है = f (a, z, t) )। बेशक, आप खुद को निर्देशांक में समय भी मिला सकते हैं। और सामान्य तौर पर, सब कुछ किया जा सकता है, उदाहरण के लिए, इस बकवास nafig को पढ़ना छोड़ दें और टहलने जाएं - इस तरह के भयानक स्पष्ट मौसम, बड़े स्वच्छ स्नोड्रिफ़्स और एक देवदार के जंगल से पत्थर का घर है!

सामान्य तौर पर, वैज्ञानिक पुनरावृत्ति प्रहार विधि का उपयोग करते हुए, हम इसे प्राप्त करते हैं:

 #include <dlfcn.h> #include <SDL.h> #include <GL/gl.h> #define W 1280 #define H 720 #define FULLSCREEN 0//SDL_FULLSCREEN const char* shader_vtx[] = { "varying vec4 p;" "void main(){gl_Position=p=gl_Vertex;pz=length(p.xy);}" }; const char* shader_frg[] = { "varying vec4 p;" "void main(){" "float " "z=1./length(p.xy)," "a=atan(px,py)+sin(p.z+z);" "gl_FragColor=" "2.*abs(.2*sin(pz*3.+z*3.)+sin(p.z+a*4.)*p.xyxx*sin(vec4(z,a,a,a)))+(z-1.)*.1;" "}" }; const char dl_nm[] = "libSDL-1.2.so.0\0" "SDL_Init\0" "SDL_SetVideoMode\0" "SDL_PollEvent\0" "SDL_GL_SwapBuffers\0" "SDL_GetTicks\0" "SDL_Quit\0" "\0" "libGL.so.1\0" "glViewport\0" "glCreateProgram\0" "glLinkProgram\0" "glUseProgram\0" "glCreateShader\0" "glShaderSource\0" "glCompileShader\0" "glAttachShader\0" "glRectf\0\0\0"; // : #define _SDL_Init ((void(*)(int))dl_ptr[0]) #define _SDL_SetVideoMode ((void(*)(int,int,int,int))dl_ptr[1]) #define _SDL_PollEvent ((void(*)(void*))dl_ptr[2]) #define _SDL_GL_SwapBuffers ((void(*)())dl_ptr[3]) #define _SDL_GetTicks ((unsigned(*)())dl_ptr[4]) #define _SDL_Quit ((void(*)())dl_ptr[5]) #define _glViewport ((void(*)(int,int,int,int))dl_ptr[6]) #define _glCreateProgram ((int(*)())dl_ptr[7]) #define _glLinkProgram ((void(*)(int))dl_ptr[8]) #define _glUseProgram ((void(*)(int))dl_ptr[9]) #define _glCreateShader ((int(*)(int))dl_ptr[10]) #define _glShaderSource ((void(*)(int,int,const char**,int))dl_ptr[11]) #define _glCompileShader ((void(*)(int))dl_ptr[12]) #define _glAttachShader ((void(*)(int,int))dl_ptr[13]) #define _glRectf ((void(*)(float,float,float,float))dl_ptr[14]) static void* dl_ptr[15]; //  -    static void dl() __attribute__((always_inline)); static void dl() { const char* pn = dl_nm; void** pp = dl_ptr; for(;;) //    { void* f = dlopen(pn, RTLD_LAZY); //  for(;;) //    precious  { while(*(pn++) != 0); //         if (*pn == 0) break; //    ,     so' *pp++ = dlsym(f, pn); } //     if (*++pn == 0) break; //   -  ,  ,   } } static void shader(const char** src, int type, int p) __attribute__((always_inline)); static void shader(const char** src, int type, int p) { int s = _glCreateShader(type); _glShaderSource(s, 1, src, 0); _glCompileShader(s); _glAttachShader(p, s); } void _start() { dl(); _SDL_Init(SDL_INIT_VIDEO); _SDL_SetVideoMode(W, H, 32, SDL_OPENGL | FULLSCREEN); _glViewport(0, 0, W, H); int p = _glCreateProgram(); shader(shader_vtx, GL_VERTEX_SHADER, p); shader(shader_frg, GL_FRAGMENT_SHADER, p); _glLinkProgram(p); _glUseProgram(p); SDL_Event e; for(;;) { _SDL_PollEvent(&e); if (e.type == SDL_KEYDOWN) break; float t = _SDL_GetTicks() / 400. + 1.; _glRectf(-t, -t, t, t); _SDL_GL_SwapBuffers(); } _SDL_Quit(); asm ( \ "xor %eax,%eax\n" \ "inc %eax\n" \ "int $0x80\n" \ ); }

यह nyashka मेरे gcc-4.5.3 में बिलकुल 1024 बाइट्स में जा रहा है।

ठीक है, हमें लगता है, यह संभावना नहीं है कि आप यहां कुछ भी बेहतर या कठिन कर सकते हैं। लगभग खुद से संतुष्ट, हम देख रहे हैं कि इस श्रेणी के अन्य लोग क्या कर रहे हैं ...

और हम हतोत्साहित हो जाते हैं।

कुछ भी नहीं बचा है, आपको असेंबलर में चढ़ना होगा।
लेकिन इसके बारे में अगली बार किसी तरह।

लिनक्स के लिए 1k / 4k इंट्रो बनाना, भाग 1

More articles: