इस लेख में कुछ तरकीबें बताई गई हैं जो मेरी छोटी कमोडोर 64 प्रोग्रामिंग प्रतियोगिता में भाग लेने वाले प्रतिभागियों ने इस्तेमाल की हैं। प्रतियोगिता के नियम सरल थे: एक निष्पादन योग्य फ़ाइल C64 (PRG) बनाएं, जो नीचे दी गई छवि बनाने के लिए दो पंक्तियों को खींचता है। जिसकी फ़ाइल आकार में छोटी है वह जीता है।


प्रतियोगिता प्रविष्टियों को खुले ट्वीट्स और निजी संदेशों में प्रकाशित किया गया था जिसमें केवल PRG फ़ाइल के बाइट्स और MD5 हैश शामिल थे।

स्रोत कोड के लिंक वाले प्रतिभागियों की सूची:

• फिलिप हेरोन ( कोड - 34 बाइट्स, विजेता)
  
• गीयर स्ट्रूम ( कोड - 34 बाइट्स)
  
• पेट्री हकीकिन ( कोड - 37 बाइट्स)
  
• मैटलवे रक्सब्लाट्स ( कोड - 38 बाइट्स)
  
• जान अहेरेनियस ( कोड - 48 बाइट्स)
  
• जेमी फुलर ( कोड - 50 बाइट्स)
  
• डेविड ए। गेर्शमैन ( कोड - 53 बाइट्स)
  
• जेन हेलस्टेन ( कोड - 56 बाइट्स)

(यदि मैं किसी को याद करता हूं, तो कृपया मुझे बताएं, मैं सूची को अपडेट करूंगा)।

लेख के बाकी हिस्सों को कुछ कोडांतरक ट्रिक के लिए समर्पित किया गया है जो प्रतियोगिता में उपयोग किए गए थे।

मूल बातें

ग्राफिक्स C64 डिफ़ॉल्ट रूप से 40x25 वर्ण एन्कोडिंग मोड में काम करता है। RAM में फ़्रेमबफ़र को दो सरणियों में विभाजित किया गया है:

• $0400 (स्क्रीन रैम, 40x25 बाइट्स)
  
• $d800 (रंगीन रैम, 40x25 बाइट्स)

एक चरित्र सेट करने के लिए, आप बाइट को ऑन-स्क्रीन रैम, $0400 (उदाहरण के लिए, $0400+y*40+x ) पर सहेजते हैं। रंग रैम को हल्के नीले रंग में डिफ़ॉल्ट रूप से आरंभ किया जाता है (रंग 14): यह वह रंग है जिसका उपयोग हम लाइनों के लिए करते हैं, अर्थात, रंग रैम को स्पर्श के बिना छोड़ा जा सकता है।

आप $d020 (सीमा) और $d021 (पृष्ठभूमि) में मेमोरी I / O रजिस्टरों का उपयोग करके सीमा और पृष्ठभूमि के रंगों को नियंत्रित करते हैं।

यदि आप सीधे एक निश्चित रेखा के ढलान को प्रोग्राम करते हैं तो दो लाइनें खींचना बहुत आसान है। यहाँ एक C कार्यान्वयन है जो लाइनों को खींचता है और स्क्रीन की सामग्री को stdout में malloc() एक पीसी पर कोड काम करने के लिए ( malloc() का उपयोग किया जाता है):

 #include <stdint.h> #include <stdio.h> #include <stdlib.h> void dump(const uint8_t* screen) { const uint8_t* s = screen; for (int y = 0; y < 25; y++) { for (int x = 0; x < 40; x++, s++) { printf("%c", *s == 0xa0 ? '#' : '.'); } printf("\n"); } } void setreg(uintptr_t dst, uint8_t v) { // *((uint8_t *)dst) = v; } int main() { // uint8_t* screenRAM = (uint_8*)0x0400; uint8_t* screenRAM = (uint8_t *)calloc(40*25, 0x20); setreg(0xd020, 0); // Set border color setreg(0xd021, 0); // Set background color int yslope = (25<<8)/40; int yf = yslope/2; for (int x = 0; x < 40; x++) { int yi = yf >> 8; // First line screenRAM[x + yi*40] = 0xa0; // Second line (X-mirrored) screenRAM[(39-x) + yi*40] = 0xa0; yf += yslope; } dump(screenRAM); } 

ऊपर दिए गए स्क्रीन कोड $20 (रिक्त) और $a0 (भरे हुए 8 × 8 ब्लॉक) हैं। यदि आप चलते हैं, तो आपको दो लाइनों वाला ASCII चित्र दिखाई देगा:

  ## ………………………………… ##
 ।। # .................................. # ।।
 ... ## .............................. # # ...
 ..... # ............................ # .....
 ...... ## ........................ ## ......
 ........ ## .................... ## ........
 .......... # .................. # ..........
 ........... ## .............. ## ..........।
 ............. # ............ # ............।
 .............. ## ........ ## ..............
 ................ ## .... ## ................
 .................. # .. # ..................
 ................... ## ...................
 .................. # .. # ..................
 ................ ## .... ## ................
 .............. ## ........ ## ..............
 ............. # ............ # ............।
 ........... ## .............. ## ..........।
 .......... # .................. # ..........
 ........ ## .................... ## ........
 ...... ## ........................ ## ......
 ..... # ............................ # .....
 ... ## .............................. # # ...
 ।। # .................................. # ।।
 ## ………………………………… ## 

समान रूप से कोडांतरक में लागू किया गया है:

 !include "c64.asm" +c64::basic_start(entry) entry: { lda #0 ; black color sta $d020 ; set border to 0 sta $d021 ; set background to 0 ; clear the screen ldx #0 lda #$20 clrscr: !for i in [0, $100, $200, $300] { sta $0400 + i, x } inx bne clrscr ; line drawing, completely unrolled ; with assembly pseudos lda #$a0 !for i in range(40) { !let y0 = Math.floor(25/40*(i+0.5)) sta $0400 + y0*40 + i sta $0400 + (24-y0)*40 + i } inf: jmp inf ; halt } 

यह पीआरजी को 286 बाइट्स के एक बड़े आकार में बदल देता है।

अनुकूलन में गोता लगाने से पहले, हम कुछ अवलोकन करते हैं।

सबसे पहले, हम जगह में रॉम रूट के साथ C64 पर काम करते हैं। टन के रूटीन हैं जो उपयोगी हो सकते हैं। उदाहरण के लिए, JSR $E544 साथ स्क्रीन को साफ़ करना।

दूसरी बात, 6502 जैसे 8-बिट प्रोसेसर पर पता गणना बोझिल हो सकती है और बहुत सारे बाइट खा सकती है। इस प्रोसेसर में एक गुणक भी नहीं है, इसलिए y*40+i जैसी गणना में आमतौर पर या तो तार्किक पारियों का एक गुच्छा या एक लुकअप तालिका शामिल होती है जो बाइट्स भी खाती है। 40 से गुणा करने से बचने के लिए, स्क्रीन कर्सर को वृद्धिशील रूप से आगे बढ़ाना सबसे अच्छा है:

  int yslope = (25<<8)/40; int yf = yslope/2; uint8_t* dst = screenRAM; for (int x = 0; x < 40; x++) { dst[x] = 0xa0; dst[(39-x)] = 0xa0; yf += yslope; if (yf & 256) { // Carry set? dst += 40; yf &= 255; } } 

हम निश्चित काउंटर yf के लिए लाइन की ढलान को जोड़ना जारी रखते हैं, और जब 8-बिट जोड़ कैरी फ्लैग सेट करता है, तो हम 40 जोड़ते हैं।

यहाँ एक वृद्धिशील असेंबलर दृष्टिकोण है:

 !include "c64.asm" +c64::basic_start(entry) !let screenptr = $20 !let x0 = $40 !let x1 = $41 !let yf = $60 entry: { lda #0 sta x0 sta $d020 sta $d021 ; kernal clear screen jsr $e544 ; set screenptr = $0400 lda #<$0400 sta screenptr+0 lda #>$0400 sta screenptr+1 lda #80 sta yf lda #39 sta x1 xloop: lda #$a0 ldy x0 ; screenRAM[x] = 0xA0 sta (screenptr), y ldy x1 ; screenRAM[39-x] = 0xA0 sta (screenptr), y clc lda #160 ; line slope adc yf sta yf bcc no_add ; advance screen ptr by 40 clc lda screenptr adc #40 sta screenptr lda screenptr+1 adc #0 sta screenptr+1 no_add: inc x0 dec x1 bpl xloop inf: jmp inf } 

82 बाइट्स के साथ, यह अभी भी बहुत भारी है। एक स्पष्ट समस्या 16-बिट पता गणना है। अप्रत्यक्ष screenptr लिए screenptr मान सेट करें:

  ; set screenptr = $0400 lda #<$0400 sta screenptr+0 lda #>$0400 sta screenptr+1 

हम 40 को जोड़कर अगली पंक्ति में screenptr का अनुवाद screenptr :

  ; advance screen ptr by 40 clc lda screenptr adc #40 sta screenptr lda screenptr+1 adc #0 sta screenptr+1 

बेशक, इस कोड को अनुकूलित किया जा सकता है, लेकिन क्या होगा यदि आप 16-बिट पते से छुटकारा पाएं? आइए देखें कि यह कैसे करना है।

ट्रिक 1. स्क्रॉलिंग!

ऑन-स्क्रीन रैम में एक लाइन बनाने के बजाय, हम केवल अंतिम स्क्रीन लाइन Y = 24 में आकर्षित करते हैं और JSR $E8EA फ़ंक्शन को JSR $E8EA साथ कॉल करते हुए पूरी स्क्रीन को स्क्रॉल करते हैं!

यहां बताया गया है कि xloop कैसे अनुकूलित किया जाता है:

  lda #0 sta x0 lda #39 sta x1 xloop: lda #$a0 ldx x0 ; hardcoded absolute address to last screen line sta $0400 + 24*40, x ldx x1 sta $0400 + 24*40, x adc yf sta yf bcc no_scroll ; scroll screen up! jsr $e8ea no_scroll: inc x0 dec x1 bpl xloop 

यह है कि प्रतिपादन कैसा दिखता है:



यह इस कार्यक्रम में मेरी पसंदीदा चाल में से एक है। लगभग सभी प्रतियोगियों ने इसे अपने दम पर पाया।

ट्रिक 2. सेल्फ-मॉडिफाई कोड

पिक्सेल मानों को संग्रहीत करने का कोड इस तरह समाप्त होता है:

  ldx x1 ; hardcoded absolute address to last screen line sta $0400 + 24*40, x ldx x0 sta $0400 + 24*40, x inc x0 dec x1 

यह 14 बाइट्स के निम्नलिखित अनुक्रम में एन्कोडेड है:

 0803: A6 22 LDX $22 0805: 9D C0 07 STA $07C0,X 0808: A6 20 LDX $20 080A: 9D C0 07 STA $07C0,X 080D: E6 22 INC $22 080F: C6 20 DEC $20 

स्व-संशोधित कोड (एसएमसी) का उपयोग करते हुए, आप इसे अधिक कॉम्पैक्ट रूप से लिख सकते हैं:

  ldx x1 sta $0400 + 24*40, x addr0: sta $0400 + 24*40 ; advance the second x-coord with SMC inc addr0+1 dec x1 

... जो 13 बाइट्स में एन्कोडेड है:

 0803: A6 22 LDX $22 0805: 9D C0 07 STA $07C0,X 0808: 8D C0 07 STA $07C0 080B: EE 09 08 INC $0809 080E: C6 22 DEC $22 

ट्रिक 3. ऑपरेशन स्टेट 'पावर ऑन'

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

• रजिस्टर ए, एक्स, वाई को शून्य के रूप में लिया जाता है
  
• सभी सीपीयू झंडे साफ कर दिए
  
• Zeropage सामग्री (पते $00 - $ff )

उसी तरह, कुछ KERNAL ROM प्रक्रियाओं को कॉल करते समय, आप किसी भी साइड इफेक्ट का पूरा लाभ उठा सकते हैं: सीपीयू झंडे, अस्थायी ज़ीरोपेज मान, आदि।

पहली अनुकूलन के बाद, आइए मशीन मेमोरी में कुछ दिलचस्प देखें:



Zeropage में हमारे उद्देश्यों के लिए कुछ उपयोगी मूल्य शामिल हैं:

• $d5 : 39 / $ 27 == लाइन की लंबाई - 1
  
• $22 : 64 / $ 40 == लाइन ढलान काउंटर के लिए प्रारंभिक मूल्य

यह आरंभीकरण के दौरान कुछ बाइट्स बचाएगा। उदाहरण के लिए:

 !let x0 = $20 lda #39 ; 0801: A9 27 LDA #$27 sta x0 ; 0803: 85 20 STA $20 xloop: dec x0 ; 0805: C6 20 DEC $20 bpl xloop ; 0807: 10 FC BPL $0805 

चूँकि $d5 में मूल्य 39 होता है, आप इसे x0 / STA जोड़ी से छुटकारा पाने के लिए काउंटर x0 को इंगित कर सकते हैं:

 !let x0 = $d5 ; nothing here! xloop: dec x0 ; 0801: C6 D5 DEC $D5 bpl xloop ; 0803: 10 FC BPL $0801 

फिलिप, प्रतियोगिता का विजेता, इसे चरम पर ले जाता है। स्ट्रिंग के अंतिम चरित्र के पते को याद करें $07C0 ( $07C0 (== $0400+24*40 )। यह मान आरंभीकरण के दौरान शून्य में मौजूद नहीं है। हालाँकि, ROM से स्क्रॉलिंग रूटीन अस्थायी ज़ारोपेज मानों के उपयोग के साइड इफेक्ट के रूप में, फ़ंक्शन के आउटपुट में $07C0 $D1-$D2 के पते में $D1-$D2 07C0 का मान होगा। इसलिए, एक पिक्सेल स्टोर करने के लिए, STA $07C0,x बजाय STA $07C0,x आप एक बाइट के लिए STA ($D1),y के अप्रत्यक्ष-इंडेक्स-इंडेक्स एड्रेसिंग का उपयोग कर सकते हैं।

ट्रिक 4. ऑप्टिमाइज़ेशन डाउनलोड करें

एक विशिष्ट C64 PRG बाइनरी में निम्नलिखित शामिल हैं:

• पहले 2 बाइट्स: डाउनलोड पता (आमतौर पर $0801 )
  
• बुनियादी बूट अनुक्रम के 12 बाइट्स

मुख्य बूट अनुक्रम इस तरह दिखता है (पते $801-$80C ):

 0801: 0B 08 0A 00 9E 32 30 36 31 00 00 00 080D: 8D 20 D0 STA $D020 

बेसिक टोकन मेमोरी लेआउट के बारे में जानकारी के बिना, यह क्रम कमोबेश '10 SYS 2061 'से मेल खाता है। पता 2061 ( $080D ) वह जगह है, जहां हमारे वास्तविक मशीन कोड प्रोग्राम तब चलता है जब BASIC दुभाषिया SYS कमांड निष्पादित करता है।

ऐसा लगता है कि 14 बाइट्स बहुत ज्यादा हैं। फिलिप, माटलेव और गीयर ने मुख्य अनुक्रम से पूरी तरह से छुटकारा पाने के लिए कई मुश्किल चालें इस्तेमाल कीं। इसके लिए PRAD लोड करने की आवश्यकता है LOAD"*",8,1 , LOAD"*",8 बाद से LOAD"*",8 PRG लोड एड्रेस (पहले दो बाइट्स) को अनदेखा करता है और हमेशा $0801 पर लोड होता है।



यहाँ दो तरीकों का इस्तेमाल किया गया था:

• ढेर की चाल
  
• बेसिक गर्म रीसेट चाल

ढेर की चाल

चाल $01F8 मूल्य पर प्रोसेसर स्टैक में $01F8 करने के लिए है जो हमारे वांछित प्रवेश बिंदु को इंगित करता है। यह एक PRG बनाकर किया जाता है, जो हमारे कोड में 16-बिट पॉइंटर से शुरू होता है और PRG को $01F8 पर लोड करता है:

  * = $01F8 !word scroll - 1 ; overwrite stack scroll: jsr $E8EA 

जैसे ही BASIC लोडर ( disassembly के बाद कोड देखें) ने लोड करना समाप्त कर दिया है और RTS का उपयोग करके कॉलर पर वापस लौटना चाहता है, यह सीधे हमारे PRG पर लौटता है।

बेसिक गर्म रीसेट चाल

यह केवल असंतुष्ट होने के बाद पीआरजी को देखकर समझाने के लिए थोड़ा आसान है।

 02E6: 20 EA E8 JSR $E8EA 02E9: A4 D5 LDY $D5 02EB: A9 A0 LDA #$A0 02ED: 99 20 D0 STA $D020,Y 02F0: 91 D1 STA ($D1),Y 02F2: 9D B5 07 STA $07B5,X 02F5: E6 D6 INC $D6 02F7: 65 90 ADC $90 02F9: 85 90 STA $90 02FB: C6 D5 DEC $D5 02FD: 30 FE BMI $02FD 02FF: 90 E7 BCC $02E8 0301: 4C E6 02 JMP $02E6 

अंतिम पंक्ति ( JMP $02E6 ) पर ध्यान दें। जेएमपी निर्देश $0301 से $0302-$0303 कूद पते के साथ शुरू होता है।

जब यह कोड पता $02E6 से शुरू होने वाली मेमोरी में लोड हो जाता है, तो $02E6 मान $0302-$0303 पते पर लिखा $02E6 है। खैर, इस स्थान का एक विशेष अर्थ है: इसमें "BASIC प्रतीक्षा चक्र" का सूचक होता है (अधिक विवरण के लिए C64 मेमोरी कार्ड देखें)। PRG को डाउनलोड करना $02E6 साथ इसे अधिलेखित करता है और इसलिए, जब एक गर्म रीसेट के बाद BASIC दुभाषिया प्रतीक्षा लूप में जाने की कोशिश करता है, तो यह इस लूप में कभी प्रवेश नहीं करता है, बल्कि इसके बजाय रेंडरिंग प्रोग्राम में जाता है!

बेसिक के लॉन्च के साथ अन्य ट्रिक्स

पेट्री ने अभी तक एक और बेसिक लॉन्च ट्रिक की खोज की है जो आपको ज़ीरोपेज में अपने स्वयं के स्थिरांक दर्ज करने की अनुमति देती है। इस पद्धति में, आप मैन्युअल रूप से अपना स्वयं का टोकन बेसिक्स प्रारंभ क्रम बनाते हैं और स्थिरांक प्रोग्राम की लाइन संख्या में स्थिरांक को एनकोड करते हैं। इनपुट पर, BASIC लाइन नंबर, ahem, अर्थात, आपके स्थिरांक को पतों में $39-$3A में संग्रहीत किया जाएगा। बहुत होशियार!

ट्रिक 5. कस्टम नियंत्रण प्रवाह

यहां एक्स-लूप का थोड़ा सरलीकृत संस्करण है जो केवल एक पंक्ति को प्रिंट करता है और फिर निष्पादन को रोकता है:

  lda #39 sta x1 xloop: lda #$a0 ldx x1 sta $0400 + 24*40, x adc yf sta yf bcc no_scroll ; scroll screen up! jsr $e8ea no_scroll: dec x1 bpl xloop ; intentionally halt at the end inf: jmp inf 

लेकिन एक गलती है। जब हमने अंतिम पिक्सेल आकर्षित किया, तो हम स्क्रीन को अब और नहीं स्क्रॉल करेंगे। इस प्रकार, अंतिम पिक्सेल की रिकॉर्डिंग के बाद स्क्रॉलिंग को रोकने के लिए अतिरिक्त शाखाओं की आवश्यकता होती है:

  lda #39 sta x1 xloop: lda #$a0 ldx x1 sta $0400 + 24*40, x dec x1 ; skip scrolling if last pixel bmi done adc yf sta yf bcc no_scroll ; scroll screen up! jsr $e8ea no_scroll: jmp xloop done: ; intentionally halt at the end inf: jmp inf 

नियंत्रण प्रवाह बहुत समान है कि सी संकलक एक संरचित कार्यक्रम से क्या उत्पादन करेगा। अंतिम स्क्रॉल को छोड़ने का कोड एक नया JMP abs निर्देश प्रस्तुत करता है जिसमें 3 बाइट्स होते हैं। सशर्त कूदता लंबाई में केवल दो बाइट्स होते हैं, क्योंकि वे सीधे संबोधन के साथ एक रिश्तेदार 8-बिट ऑपरेंड का उपयोग करके जम्प एड्रेस को एनकोड करते हैं।

JMP "अंतिम स्क्रॉल को छोड़ें" को स्क्रॉल कॉल को लूप के शीर्ष पर ले जाकर और नियंत्रण प्रवाह संरचना को थोड़ा बदलकर टाला जा सकता है। यहां बताया गया है कि फिलिप ने इसे कैसे लागू किया:

  lda #39 sta x1 scroll: jsr $e8ea xloop: lda #$a0 ldx x1 sta $0400 + 24*40, x adc yf sta yf dec x1 ; doesn't set carry! inf: bmi inf ; hang here if last pixel! bcc xloop ; next pixel if no scroll bcs scroll ; scroll up and continue 

यह एक तीन-बाइट JMP को पूरी तरह से समाप्त कर देता है और अन्य JMP को दो-बाइट सशर्त शाखा में परिवर्तित करता है, जिससे कुल 4 बाइट बचती हैं।

ट्रिक 6. बिट कम्प्रेशन वाली लाइनें

कुछ तत्व लाइन ढलान काउंटर का उपयोग नहीं करते हैं, बल्कि बिट्स को 8-बिट निरंतर में संपीड़ित करते हैं। इस तरह की पैकेजिंग इस तथ्य पर आधारित है कि लाइन के साथ पिक्सेल की स्थिति एक दोहराए जाने वाले 8-पिक्सेल पैटर्न से मेल खाती है:

 int mask = 0xB6; // 10110110 uint8_t* dst = screenRAM; for (int x = 0; x < 40; x++) { dst[x] = 0xA0; if (mask & (1 << (x&7))) { dst += 40; // go down a row } } 

यह काफी कॉम्पैक्ट असेंबलर के लिए अनुवाद करता है। हालांकि, झुकाव काउंटर विकल्प आमतौर पर और भी छोटे होते हैं।

विजेता

यहां फिलिप से 34-बाइट प्रतियोगिता जीतने का कार्यक्रम है। उपर्युक्त चाल में से अधिकांश उसके कोड में अच्छी तरह से काम करती हैं:

 ov = $22 ; == $40, initial value for the overflow counter ct = $D5 ; == $27 / 39, number of passes. Decrementing, finished at -1 lp = $D1 ; == $07C0, pointer to bottom line. Set by the kernal scroller ; Overwrite the return address of the kernal loader on the stack ; with a pointer to our own code * = $01F8 .word scroll - 1 scroll: jsr $E8EA ; Kernal scroll up, also sets lp pointer to $07C0 loop: ldy ct ; Load the decrementing counter into Y (39 > -1) lda #$A0 ; Load the PETSCII block / black col / ov step value sta $D020, y ; On the last two passes, sets the background black p1: sta $07C0 ; Draw first block (left > right line) sta (lp), y ; Draw second block (right > left line) inc p1 + 1 ; Increment pointer for the left > right line adc ov ; Add step value $A0 to ov sta ov dec ct ; Decrement the Y counter bmi * ; If it goes negative, we're finished bcc loop ; Repeat. If ov didn't overflow, don't scroll bcs scroll ; Repeat. If ov overflowed, scroll 

लेकिन 34 बाइट्स पर क्यों रहते हैं?

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

• फिलिप - 33 बाइट्स
  
• फिलिप - 32 बाइट्स
  
• पेट्री - 31 बाइट्स
  
• फिलिप - 29 बाइट्स

देखना सुनिश्चित करें - कई असली मोती हैं।

---

पढ़ने के लिए धन्यवाद। और भाग लेने के लिए मैटलेव, फिल, गीर, पेट्री, जेमी, इयान और डेविड का विशेष धन्यवाद (मुझे उम्मीद है कि मैंने किसी को याद नहीं किया - ट्विटर पर सभी उल्लेखों को ट्रैक करना वास्तव में मुश्किल था!]

पीएस पेट्री ने मेरी प्रतियोगिता को "वार्षिक" कहा, इसलिए, उह, शायद आपको अगले साल देखें।