ASCII रेफरेंस टेबल

अपने ब्राउज़र में स्थानीय रूप से डेसिमल, हेक्स, ऑक्टल, 8-बिट बाइनरी, एस्केप और HTML एंटिटी द्वारा 7-बिट US-ASCII (0-127) और एक्सटेंडेड Latin-1 (128-255) खोजें।

कोई अपलोड नहींसाइन-अप की आवश्यकता नहींतुरंत परिणाम
7-Bit ASCII और Latin-1Dec, Hex, Oct, Bin और HTMLटेक्स्ट बाइट इंस्पेक्टर
ASCII तालिका खोलें
ऑफ़लाइन इंजन तैयार हैब्राउज़र में 100% निजी वर्कस्पेस • शून्य क्लाउड अपलोड
100% निजी • शून्य सर्वर फ़ाइल अपलोड

Utiliome का मुफ़्त ASCII रेफरेंस टेबल क्यों उपयोग करें?

सख्त गोपनीयता और त्वरित निष्पादन के लिए निर्मित। कोई सदस्यता या पंजीकरण आवश्यक नहीं है।

ANSI X3.4 और ISO-8859-1 संपूर्ण 0-255 चार्ट

एक्सटेंडेड 8-बिट ISO-8859-1 Latin-1 (128-255) C1 कंट्रोल्स और पश्चिमी यूरोपीय प्रतीकों के साथ सभी 128 मानक 7-बिट US-ASCII पोजीशन (RFC 20 C0 कंट्रोल्स और प्रिंटेबल कैरेक्टर) को कवर करता है।

सिंक्रोनाइज़्ड मल्टी-बेस और एस्केप कॉलम

डेसिमल (0-255), हेक्साडेसिमल (0x00-0xFF), 3-अंकीय ऑक्टल (000-377), पैडेड 8-बिट बाइनरी, C/JS बैकस्लैश एस्केप, टर्मिनल कैरेट नोटेशन (^@, ^M, ^?) और HTML एंटिटी को क्रॉस-रेफरेंस करता है।

इंस्टेंट मल्टी-फ़ील्ड सर्च और ग्रुप फ़िल्टर

प्रिंटेबल ग्लिफ़, LF या ESC जैसे कंट्रोल निमोनिक, 0x1B जैसे हेक्स बाइट, 8-बिट बाइनरी पैटर्न, कैरेट सीक्वेंस या HTML एंटिटी टाइप करके सभी 256 बाइट पंक्तियों को तुरंत फ़िल्टर करें।

ज़ीरो-लेटेंसी क्लाइंट-साइड लुकअप

बिना किसी नेटवर्क राउंड-ट्रिप या बाहरी डिपेंडेंसी के सीधे ब्राउज़र मेमोरी में सभी फ़िल्टरिंग, रेंज टॉगलिंग और वन-क्लिक कोड कॉपी करने का कार्य करता है।

Utiliome बनाम पारंपरिक क्लाउड विकल्प

पुराने क्लाउड टूल्स के विरुद्ध हमारे लोकल-फ़र्स्ट WebAssembly इंजन की तुलना करें।

विशेषता Utiliome (लोकल ब्राउज़र) पुराने क्लाउड कनवर्टर
ANSI X3.4 और ISO-8859-1 संपूर्ण 0-255 चार्ट एक्सटेंडेड 8-बिट ISO-8859-1 Latin-1 (128-255) C1 कंट्रोल्स और पश्चिमी यूरोपीय प्रतीकों के साथ सभी 128 मानक 7-बिट US-ASCII पोजीशन (RFC 20 C0 कंट्रोल्स और प्रिंटेबल कैरेक्टर) को कवर करता है। उन्नत कस्टमाइज़ेशन के बिना सीमित विकल्प
सिंक्रोनाइज़्ड मल्टी-बेस और एस्केप कॉलम डेसिमल (0-255), हेक्साडेसिमल (0x00-0xFF), 3-अंकीय ऑक्टल (000-377), पैडेड 8-बिट बाइनरी, C/JS बैकस्लैश एस्केप, टर्मिनल कैरेट नोटेशन (^@, ^M, ^?) और HTML एंटिटी को क्रॉस-रेफरेंस करता है। बाहरी टूल्स या मैनुअल प्रोसेसिंग की आवश्यकता
डेटा गोपनीयता और प्रोसेसिंग 100% ब्राउज़र में लोकल प्रोसेसिंग (सर्वर अपलोड शून्य) डेटा को बाहरी क्लाउड सर्वर पर अपलोड करता है
मूल्य और अकाउंट आवश्यकता बिना साइन-अप के हमेशा के लिए 100% मुफ़्त अकाउंट साइन-अप या पेड सब्सक्रिप्शन अनिवार्य
यह कैसे काम करता है

3 आसान चरणों में ASCII रेफरेंस टेबल का उपयोग कैसे करें

किसी सॉफ़्टवेयर इंस्टॉलेशन की आवश्यकता नहीं है। सब कुछ सीधे आपके वेब ब्राउज़र में चलता है।

1

एक ASCII रेंज या कंट्रोल ग्रुप चुनें

संपूर्ण 0 से 255 बाइट टेबल देखें या पंक्तियों को C0 कंट्रोल कोड (0-31 और 127), प्रिंटेबल 7-बिट US-ASCII (32-126), या एक्सटेंडेड ISO-8859-1 Latin-1 (128-255) तक सीमित करें।

2

बेस, निमोनिक, कैरेट या एस्केप द्वारा फ़िल्टर करें

कोई भी कैरेक्टर, निमोनिक (NUL, CR, LF, DEL), डेसिमल नंबर, हेक्स वैल्यू (0x0A, 7F), बाइनरी बाइट (01000001), कैरेट शॉर्टकट (^C), C/JS एस्केप (\r, \x1b), या HTML एंटिटी ( ) टाइप करें।

3

फ़ॉर्मेटेड लिटरल्स को सीधे कॉपी करें

किसी भी मिलती-जुलती पंक्ति में किसी मान पर क्लिक करें ताकि उसका हेक्स लिटरल, डेसिमल इंटीजर, 8-बिट बाइनरी स्ट्रिंग, बैकस्लैश एस्केप, या HTML एंटिटी सीधे आपके पार्सर या सोर्स फ़ाइल में कॉपी हो सके।

क्विक रेफरेंस वॉकथ्रू: कंट्रोल कोड, प्रिंटेबल ग्लिफ़ और एक्सटेंडेड बाइट्स

त्वरित उत्तर: 0 से 255 तक के किसी भी बाइट मान को उसके कंट्रोल निमोनिक या ग्लिफ़, डेसिमल, हेक्स, ऑक्टल, 8-बिट बाइनरी, C/JavaScript एस्केप, टर्मिनल कैरेट नोटेशन और HTML एंटिटी से क्रॉस-रेफरेंस करने के लिए देखें—यह HTTP CRLF फ़्रेमिंग, ANSI टर्मिनल सीक्वेंस और बाइनरी वायर प्रोटोकॉल को डीबग करने के लिए आदर्श है।

लेक्सर लिखते समय, TCP पैकेट डंप का निरीक्षण करते समय, या सीरियल और टर्मिनल I/O को कॉन्फ़िगर करते समय, डेवलपर्स लगातार रॉ बाइट मानों और प्रतीकात्मक अभ्यावेदनों (symbolic representations) के बीच अनुवाद करते हैं। नीचे C0 कंट्रोल्स (0–31, 127), प्रिंटेबल 7-बिट US-ASCII (32–126), और एक्सटेंडेड ISO-8859-1 Latin-1 (128–255) में सबसे अधिक उपयोग की जाने वाली एंकर पंक्तियों का एक रेफरेंस स्नैपशॉट दिया गया है:

Dec  Hex   Oct  Binary    Glyph / Mnemonic  Caret  C / JS Escape  HTML Entity
---  ----  ---  --------  ----------------  -----  -------------  -----------
0    0x00  000  00000000  <NUL> (Null)      ^@     \0             &#0;
9    0x09  011  00001001  <HT>  (Tab)       ^I     \t             &#9;
10   0x0A  012  00001010  <LF>  (Line Feed) ^J     \n             &#10;
13   0x0D  015  00001101  <CR>  (Return)    ^M     \r             &#13;
27   0x1B  033  00011011  <ESC> (Escape)    ^[     \x1B           &#27;
32   0x20  040  00100000  <SP>  (Space)     -      " "            &#32;
48   0x30  060  00110000  0                 -      0              &#48;
65   0x41  101  01000001  A                 -      A              &#65;
97   0x61  141  01100001  a                 -      a              &#97;
126  0x7E  176  01111110  ~                 -      ~              &#126;
127  0x7F  177  01111111  <DEL> (Delete)    ^?     \x7F           &#127;
160  0xA0  240  10100000  <NBSP>            -      \xA0           &nbsp;
169  0xA9  251  10101001  ©                 -      \xA9           &copy;
255  0xFF  377  11111111  ÿ                 -      \xFF           &yuml;

प्रैक्टिकल प्रोटोकॉल लुकअप उदाहरण

टेबल के साथ रॉ वायर बाइट्स को मैप करने से प्रोटोकॉल फ़्रेमिंग और टर्मिनल कंट्रोल सीक्वेंस तुरंत स्पष्ट हो जाते हैं:

1. HTTP/1.1 Header Terminator (RFC 9112):
   Hex bytes:  0D 0A 0D 0A
   Mnemonics:  <CR><LF><CR><LF>
   Escapes:    "\r\n\r\n" (Decimal: 13, 10, 13, 10)

2. ANSI CSI Green Terminal Prompt:
   Hex bytes:  1B 5B 33 32 6D
   Decoded:    <ESC> (0x1B / ^[) + '[' (0x5B) + '3' (0x33) + '2' (0x32) + 'm' (0x6D)
   JS literal: "\x1b[32m"

7-बिट US-ASCII बिटवाइज़ लेआउट, कैरेट अरिथमेटिक और एक्सटेंडेड 8-बिट बारीकियां

त्वरित उत्तर: मानक US-ASCII (ANSI X3.4 / ISO/IEC 646 / RFC 20) 7 बिट्स (0x00 से 0x7F) में 128 कैरेक्टर व्यवस्थित करता है ताकि केस कन्वर्ज़न, डिजिट पार्सिंग और कैरेट नोटेशन सिंगल-बिट ऑपरेशंस में बदल जाएं, जबकि एक्सटेंडेड बाइट्स 0x80 से 0xFF तक ISO-8859-1, Windows-1252 और UTF-8 में मूल रूप से भिन्न होते हैं।

7-बिट US-ASCII का गणितीय बिट लेआउट (ANSI X3.4 / RFC 20)

7-बिट US-ASCII ग्रिड (b6 b5 b4 b3 b2 b1 b0, जो 0x00 से 0x7F तक फैला है) को जानबूझकर इस तरह इंजीनियर किया गया था ताकि हार्डवेयर सर्किट और लो-लेवल पार्सर बिना लुकअप टेबल के सिंगल बिटवाइज़ निर्देशों का उपयोग करके कैरेक्टर को वर्गीकृत और परिवर्तित कर सकें:

  • बिट 5 (0x20, डेसिमल 32) केस फ़ोल्डिंग: अपरकेस अक्षर A–Z 0x41–0x5A (01000001–01011010) पर होते हैं, जबकि लोअरकेस अक्षर a–z 0x61–0x7A (01100001–01111010) पर होते हैं। प्रत्येक अपरकेस/लोअरकेस जोड़ी में केवल बिट 5 का अंतर होता है। किसी ASCII अक्षर को लोअरकेस में बदलना byte | 0x20 है, अपरकेस में बदलना byte & ~0x20 है, और केस टॉगल करना byte ^ 0x20 है।
  • लो-निबल BCD डिजिट अलाइनमेंट: अंक 0–9 0x30–0x39 (00110000–00111001) पर होते हैं। byte & 0x0F के माध्यम से ऊपरी 0011 निबल को हटाने (या 0x30 घटाने) से सीधे बाइनरी-कोडेड इंटीजर 0 से 9 प्राप्त होता है।
  • बिट 6 (0x40, डेसिमल 64) कैरेट नोटेशन और Ctrl की (Key) मैपिंग: टर्मिनल ड्राइवर Ctrl कॉर्ड्स का अनुवाद करते हैं और बिट 6 (byte ^ 0x40) को फ़्लिप करके C0 कंट्रोल कोड (0x00–0x1F) तथा <DEL> (0x7F) प्रदर्शित करते हैं। परिणामस्वरूप, <NUL> (0x00 ^ 0x40 = 0x40) ^@ के रूप में रेंडर होता है, <ETX> (0x03 ^ 0x40 = 0x43) ^C (SIGINT) के रूप में, <LF> (0x0A ^ 0x40 = 0x4A) ^J के रूप में, <CR> (0x0D ^ 0x40 = 0x4D) ^M के रूप में, <ESC> (0x1B ^ 0x40 = 0x5B) ^[ के रूप में, और <DEL> (0x7F ^ 0x40 = 0x3F) ^? के रूप में रेंडर होता है।

128–255 एक्सटेंडेड बाइट ट्रैप: ISO-8859-1 बनाम Windows-1252 बनाम UTF-8

चूंकि US-ASCII 8वें बिट (b7, 0x80) को अनसेट छोड़ देता है, इसलिए 128 से 255 (0x80–0xFF) के मानों के लिए असंगत 8-बिट एक्सटेंशन उभरे। इन्हें आपस में मिलाना क्लासिक टेक्स्ट करप्शन (mojibake) का मूल कारण है:

  1. ISO-8859-1 (Latin-1): यह C1 कंट्रोल कोड (जैसे <PAD>, <NEL>, और <CSI>) के लिए 128–159 (0x80–0x9F) को आरक्षित करता है और <NBSP> (0xA0) से शुरू होने वाले पश्चिमी यूरोपीय विराम चिह्नों, मुद्रा प्रतीकों और एक्सेंट वाले अक्षरों को 160–255 (0xA0–0xFF) असाइन करता है। महत्वपूर्ण रूप से, Unicode ने ISO-8859-1 को अपने U+0080–U+00FF Latin-1 सप्लीमेंट ब्लॉक के रूप में अपनाया है, इसलिए ISO-8859-1 बाइट मान Unicode कोड पॉइंट नंबरों से 1:1 मेल खाते हैं।
  2. Windows-1252 (CP1252): यह 32 0x80–0x9F C1 कंट्रोल पोजीशनों में से 27 को प्रिंटेबल ग्लिफ़ के रूप में फिर से असाइन करता है—जिसमें € (0x80, जो Unicode में U+20AC है), — (0x97, U+2014), और कर्ली कोट्स (0x91–0x94) शामिल हैं। WHATWG एनकोडिंग मानक के अनुसार, वेब ब्राउज़र HTML charset=iso-8859-1 घोषणाओं को windows-1252 के रूप में मानते हैं।
  3. UTF-8: यह केवल 7-बिट US-ASCII (0x00–0x7F) के साथ सटीक सिंगल-बाइट संगतता साझा करता है। UTF-8 में, रॉ बाइट्स 0x80–0xFF कभी भी मान्य सिंगल-बाइट Latin-1 कैरेक्टर नहीं होते हैं: U+0080–U+00FF मानों के लिए 2-बाइट UTF-8 सीक्वेंस (0xC2 0x80 से 0xC3 0xBF तक) की आवश्यकता होती है। 0xE9 (é) जैसे रॉ Latin-1 बाइट को UTF-8 पार्सर में पास करने से डिकोडिंग एरर (U+FFFD) ट्रिगर होता है, जबकि UTF-8 0xC3 0xA9 को ISO-8859-1 के रूप में पढ़ने पर दो-कैरेक्टर वाली mojibake स्ट्रिंग é बनती है।

ASCII रेफरेंस टेबल बनाम कैरेक्टर इंस्पेक्टर और हेक्स डिकोडर

त्वरित उत्तर: स्टैटिक 0 से 255 बाइट मैपिंग, कंट्रोल निमोनिक्स, कैरेट शॉर्टकट और एस्केप देखने के लिए ASCII रेफरेंस टेबल का उपयोग करें। छिपे हुए Unicode या UTF-8 बाइट्स के लिए पेस्ट की गई स्ट्रिंग्स का ऑडिट करने के लिए यूनिकोड कैरेक्टर इंस्पेक्टर का उपयोग करें, या पूर्ण हेक्साडेसिमल पेलोड को एनकोड और डिकोड करने के लिए हेक्स से टेक्स्ट कन्वर्टर का उपयोग करें।

अपनी आवश्यकता के अनुसार विशेष टूल चुनें—चाहे आपको बाइट-लेवल रेफरेंस चार्ट, स्ट्रिंग-लेवल Unicode डायग्नोस्टिक्स, बल्क हेक्साडेसिमल पेलोड कन्वर्ज़न, या फ़ॉर्मेटेड टेक्स्ट टेबल की आवश्यकता हो:

क्षमता ASCII रेफरेंस टेबल यूनिकोड कैरेक्टर इंस्पेक्टर हेक्स से टेक्स्ट कन्वर्टर ASCII, Unicode बॉक्स और प्लेन टेक्स्ट टेबल फ़ॉर्मेटर
मुख्य उद्देश्य US-ASCII और ISO-8859-1 के लिए खोजने योग्य 0–255 लुकअप टेबल प्रति-कैरेक्टर Unicode डायग्नोस्टिक और हिडन-कैरेक्टर डिटेक्टर हेक्स बाइट स्ट्रिंग्स और पठनीय टेक्स्ट के बीच बल्क कन्वर्ज़न अलाइन किए गए ASCII +---+ और Unicode बॉक्स-ड्रॉइंग टेबल बनाना
कैरेक्टर स्कोप 256 सिंगल-बाइट कोड (0x00–0x7F + Latin-1 0x80–0xFF) सभी 1,112,064 Unicode स्केलर मान (U+0000–U+10FFFF) मनमाने मल्टी-बाइट UTF-8 या ASCII बाइट स्ट्रीम्स CSV, TSV, JSON, या Markdown से मनमाना टैबुलर डेटा
कंट्रोल और कैरेट जानकारी पूर्ण C0/C1 निमोनिक्स (<NUL>–<DEL>), कैरेट (^M), ऑक्टल, बाइनरी एम्बेडेड <ZWSP>, <BOM>, <NBSP>, और bidi ओवरराइड्स को फ़्लैग करता है रॉ हेक्स बाइट्स (48 65 6C 6C 6F) को डिकोड या एनकोड करता है यह कोई एनकोडिंग लुकअप टूल नहीं है
सर्वोत्तम उपयोग पार्सर लिखते समय हेक्स/बाइनरी/एस्केप कोड चेक करना यह डीबग करना कि पेस्ट की गई स्ट्रिंग regex, JSON या इक्वैलिटी में क्यों विफल हो जाती है पैकेट कैप्चर या हेक्स डंप को टेक्स्ट में या टेक्स्ट से अनुवाद करना CLI आउटपुट, README डॉक्स और SQL-स्टाइल ASCII ग्रिड को फ़ॉर्मेट करना
  • जब भी आपके पास बाइट 255 से परे मल्टी-बाइट UTF-8 इमोजी, ज़ीरो-विड्थ स्पेस, या भ्रामक होमोग्लिफ़ वाली कोई वास्तविक स्ट्रिंग या फ़ाइल हो, तो यूनिकोड कैरेक्टर इंस्पेक्टर खोलें।
  • लंबे हेक्साडेसिमल बाइट डंप (0D 0A स्ट्रीम्स, Wireshark पेलोड, या हेक्स-एनकोडेड लॉग्स) को सीधे UTF-8 टेक्स्ट में या इसके विपरीत डिकोड करने के लिए हेक्स से टेक्स्ट कन्वर्टर का उपयोग करें।
  • यदि आप कैरेक्टर कोड देखने के बजाय डॉक्यूमेंटेशन या कोड कमेंट्स के लिए अलाइन किए गए प्लेन-टेक्स्ट +---+---+ या Unicode ┌───┐ डेटा ग्रिड जनरेट करना चाहते हैं, तो ASCII, Unicode बॉक्स और प्लेन टेक्स्ट टेबल फ़ॉर्मेटर का उपयोग करें, या बैच U+XXXX कोड पॉइंट ट्रांसफ़ॉर्मेशन के लिए यूनिकोड कन्वर्टर पर जाएं।
अक्सर पूछे जाने वाले प्रश्न

ASCII रेफरेंस टेबल: अक्सर पूछे जाने वाले प्रश्न और गाइड

Utiliome के मुफ़्त ऑनलाइन ascii टेबल का उपयोग करने के बारे में सब कुछ।

7-बिट US-ASCII (0-127) और एक्सटेंडेड ASCII (128-255) के बीच क्या अंतर है?

मानक US-ASCII (ANSI X3.4 / RFC 20) 7 बिट्स (0 से 127, या 0x00 से 0x7F) का उपयोग करके सख्ती से 128 कोड पोजीशन परिभाषित करता है: 33 नॉन-प्रिंटिंग कंट्रोल कोड (0 से 31 और 127 <DEL>) और 95 प्रिंटेबल ग्लिफ़ (32 <SP> से 126 ~ तक)। कोड 128 से 255 (0x80 से 0xFF) 8वें बिट को सेट करते हैं और चुने गए 8-बिट कैरेक्टर एनकोडिंग पर निर्भर करते हैं। यह रेफरेंस 128 से 255 के लिए ISO-8859-1 (Latin-1) का उपयोग करता है क्योंकि इसके संख्यात्मक कोड मान Unicode स्केलर मान U+0080 से U+00FF तक समान रूप से मैप होते हैं।

Windows और HTTP में CRLF (13, 10) का उपयोग क्यों किया जाता है जबकि Unix और Linux में LF (10) का उपयोग होता है?

इलेक्ट्रोमैकेनिकल टेलीटाइप को एक नई लाइन शुरू करने के लिए दो अलग-अलग भौतिक क्रियाओं की आवश्यकता होती थी: कैरिज रिटर्न (<CR>, डेसिमल 13, 0x0D, \r) प्रिंट कैरिज को बाएं मार्जिन पर वापस लाता था, और लाइन फ़ीड (<LF>, डेसिमल 10, 0x0A, \n) पेपर प्लेटन को एक लाइन ऊपर रोल करता था। HTTP/1.1, SMTP, और FTP सहित इंटरनेट प्रोटोकॉल—साथ ही CP/M, DOS, और Windows—ने दो-बाइट <CR><LF> (0D 0A) सीक्वेंस को मानक बनाया, जबकि Multics, Unix, Linux, और आधुनिक macOS ने सिंगल-बाइट <LF> (0A) को एक अंतर्निहित (implicit) न्यूलाइन के रूप में अपनाया।

क्या एक्सटेंडेड Latin-1 बाइट्स (128-255) UTF-8 के बाइट-समान (byte-identical) हैं?

नहीं। केवल 7-बिट US-ASCII मान 0 से 127 (0x00 से 0x7F) ही UTF-8 में समान सिंगल-बाइट एनकोडिंग साझा करते हैं। हालांकि ISO-8859-1 बाइट्स 128 से 255 के कोड पॉइंट नंबर Unicode U+0080 से U+00FF के बिल्कुल समान हैं, UTF-8 उस रेंज को लीड बाइट 0xC2 या 0xC3 से शुरू होने वाले दो-बाइट सीक्वेंस के रूप में एनकोड करता है। उदाहरण के लिए, © ISO-8859-1 में सिंगल बाइट 0xA9 (डेसिमल 169) है, लेकिन UTF-8 में दो बाइट्स 0xC2 0xA9 है।

ASCII कोड से टर्मिनल कैरेट नोटेशन (^C, ^M, ^[, ^?) की गणना कैसे की जाती है?

कैरेट नोटेशन 0x40 (डेसिमल 64) के साथ बिटवाइज़ XOR के माध्यम से बिट 6 को टॉगल करके नॉन-प्रिंटिंग C0 कंट्रोल बाइट्स (0x00 से 0x1F) और <DEL> (0x7F) को प्रिंटेबल ASCII कैरेक्टर में बदलता है। <ETX> (0x03) को 0x40 के साथ XOR करने पर 0x43 ('C') मिलता है, जिसे ^C लिखा जाता है। इसी तरह, <CR> (0x0D ^ 0x40 = 0x4D) ^M बन जाता है, <ESC> (0x1B ^ 0x40 = 0x5B) ^[ बन जाता है, और <DEL> (0x7F ^ 0x40 = 0x3F) ^? बन जाता है।

DEL को कंट्रोल कैरेक्टर 0 से 31 के साथ समूहित करने के बजाय 127 क्यों असाइन किया गया है?

7-ट्रैक पंच्ड पेपर टेप पर, कोड 0 (<NUL>, बाइनरी 0000000) का अर्थ था कि कोई छेद पंच नहीं किया गया, जबकि कोड 127 (<DEL>, बाइनरी 1111111) का अर्थ था कि सभी सातों छेद पंच किए गए हैं। चूंकि टाइपिंग की गलती के बाद भौतिक छेदों को वापस बंद नहीं किया जा सकता था, इसलिए ऑपरेटर टेप को पीछे करते थे और गलत कैरेक्टर के ऊपर सभी सात छेद पंच कर देते थे ताकि वह 127 (<DEL>) में बदल जाए, जिसे हार्डवेयर टेप रीडर अपने आप छोड़ (skip) देते थे।