Cyber-Parallel-Dataset-Indic / te /Assembly Language Step-by-Step Programming with DOS and Linux - Jeff Duntemann_indic_translation.jsonl
| {"en":"Assembly Language Step-by-Step: Programming with DOS and Linux is a book.","translation":"అసెంబ్లీ లాంగ్వేజ్ స్టెప్-బై-స్టెప్: ప్రోగ్రామింగ్ విత్ DOS మరియు Linux ఒక పుస్తకం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book covers 16-bit assembler programming concepts.","translation":"ఈ పుస్తకం 16-బిట్ అసెంబ్లర్ ప్రోగ్రామింగ్ భావనలను వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Jeff Duntemann is the author of this book.","translation":"జెఫ్ డంటెమన్ ఈ పుస్తక రచయిత.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book includes examples for both DOS and Linux operating systems.","translation":"ఈ పుస్తకంలో DOS మరియు Linux ఆపరేటింగ్ సిస్టమ్లకు ఉదాహరణలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It teaches how to write, test, and debug assembly programs.","translation":"అసెంబ్లీ ప్రోగ్రామ్లను ఎలా రాయాలో, పరీక్షించాలో మరియు డీబగ్ చేయాలో ఇది నేర్పుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book explains the use of NASM-IDE.","translation":"ఈ పుస్తకం NASM-IDE వినియోగాన్ని వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It also covers the x86 CPU and its segmented memory system.","translation":"ఇది x86 CPU మరియు దాని విభజించబడిన మెమరీ సిస్టమ్ను కూడా కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The author discusses machine instructions.","translation":"రచయిత మెషిన్ సూచనలను చర్చిస్తాడు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book provides a foundation for creating assembly language programs.","translation":"అసెంబ్లీ లాంగ్వేజ్ ప్రోగ్రామ్లను రూపొందించడానికి ఈ పుస్తకం ఒక పునాదిని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It explains how to use procedures and macros.","translation":"ఇది విధానాలు మరియు స్థూలాలను ఎలా ఉపయోగించాలో వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book is a guide to assembly language.","translation":"ఈ పుస్తకం అసెంబ్లీ భాషకు ఒక మార్గదర్శి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book is updated to include coverage of Linux.","translation":"Linux కవరేజీని చేర్చడానికి పుస్తకం అప్డేట్ చేయబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The second edition is expanded.","translation":"రెండవ ఎడిషన్ విస్తరించబడింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book systematically covers all the steps involved in writing assembly programs.","translation":"అసెంబ్లీ ప్రోగ్రామ్లను రాయడంలో, పరీక్షించడంలో మరియు డీబగ్ చేయడంలో ఉన్న అన్ని దశలను ఈ పుస్తకం క్రమబద్ధంగా వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The author presents working example programs for both DOS and Linux.","translation":"రచయిత DOS మరియు Linux రెండింటికీ పనిచేసే ఉదాహరణ ప్రోగ్రామ్లను అందిస్తాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book offers a comprehensive look at the complexities of assembly programming.","translation":"అసెంబ్లీ ప్రోగ్రామింగ్ యొక్క సంక్లిష్టతలపై ఈ పుస్తకం సమగ్రమైన రూపాన్ని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It provides the foundation to create executable assembly language programs.","translation":"అసెంబ్లీ లాంగ్వేజ్ ప్రోగ్రామ్లను అమలు చేయడానికి ఇది పునాదిని అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book explains the most used elements of the 86-family instruction set.","translation":"86-కుటుంబ సూచన సెట్లోని అత్యంత ఉపయోగించే అంశాలను ఈ పుస్తకం వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It teaches about DEBUG, a useful tool for assembly language programmers.","translation":"అసెంబ్లీ లాంగ్వేజ్ ప్రోగ్రామర్లకు ఉపయోగకరమైన సాధనం అయిన DEBUG గురించి ఇది బోధిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book examines the operations that machine instructions force the CPU to perform.","translation":"మెషిన్ సూచనలు CPUని నిర్వహించమని బలవంతం చేసే కార్యకలాపాలను ఈ పుస్తకం పరిశీలిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"button is a handy way to do this if your calculator has one.","translation":"మీ కాలిక్యులేటర్లో బటన్ ఉంటే, ఇది చేయడానికి ఇది చాలా సులభమైన మార్గం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Remember what you're doing: evaluating each column in decimal and keeping a running total.","translation":"మీరు ఏమి చేస్తున్నారో గుర్తుంచుకోండి: ప్రతి కాలమ్ను దశాంశంలో అంచనా వేయండి మరియు రన్నింగ్ టోటల్ను ఉంచండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Now, move to the third column from the right. This one contains a 7.","translation":"ఇప్పుడు, కుడి నుండి మూడవ కాలమ్కు వెళ్లండి. ఇందులో 7 ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The value of the third column is 16 × 16, or 256.","translation":"మూడవ కాలమ్ విలువ 16 × 16, లేదా 256.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Multiply 256 × 7 on your calculator, and add the product to your running total.","translation":"మీ కాలిక్యులేటర్లో 256 × 7 గుణించండి మరియు ఉత్పత్తిని మీ రన్నింగ్ టోటల్కు జోడించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Retrieve the running total from your calculator memory.","translation":"మీ కాలిక్యులేటర్ మెమరీ నుండి రన్నింగ్ టోటల్ను తిరిగి పొందండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The total should be 1954, which is the decimal equivalent of 7A2H.","translation":"మొత్తం 1954 ఉండాలి, ఇది 7A2H యొక్క దశాంశ సమానం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Okay—let's try it again, more quickly, with a little less natter and a much larger number: C6F0DBH.","translation":"అలాగే—మరొకసారి ప్రయత్నిద్దాం, వేగంగా, కొంచెం తక్కువ మాటలతో మరియు చాలా పెద్ద సంఖ్యతో: C6F0DBH.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"First, evaluate the units column. B × 1 = 11 × 1 = 11.","translation":"ముందుగా, యూనిట్ల కాలమ్ను అంచనా వేయండి. B × 1 = 11 × 1 = 11.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Start your running total with 11.","translation":"మీ రన్నింగ్ టోటల్ను 11తో ప్రారంభించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 16s column. D × 16 = 13 × 16 = 208.","translation":"16ల కాలమ్ను అంచనా వేయండి. D × 16 = 13 × 16 = 208.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Add 208 to your running total.","translation":"మీ రన్నింగ్ టోటల్కు 208ని జోడించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 256s column. 0 × 256 = 0. Move on.","translation":"256ల కాలమ్ను అంచనా వేయండి. 0 × 256 = 0. ముందుకు సాగండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 4,096s column. F × 4,096 = 15 × 4,096 = 61,440.","translation":"4,096ల కాలమ్ను అంచనా వేయండి. F × 4,096 = 15 × 4,096 = 61,440.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Add it to your running total.","translation":"దీన్ని మీ రన్నింగ్ టోటల్కు జోడించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 65,536s column. 6 × 65,536 = 393,216.","translation":"65,536ల కాలమ్ను అంచనా వేయండి. 6 × 65,536 = 393,216.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Add it to the running total.","translation":"దీన్ని రన్నింగ్ టోటల్కు జోడించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 1,048,576s column. C × 1,048,576 = 12 × 1,048,576 = 12,582,912.","translation":"1,048,576ల కాలమ్ను అంచనా వేయండి. C × 1,048,576 = 12 × 1,048,576 = 12,582,912.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Add it to your total.","translation":"దీన్ని మీ మొత్తంకు జోడించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The running total should be 13,037,787.","translation":"రన్నింగ్ మొత్తం 13,037,787 ఉండాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Computers work in base 2 and base 16.","translation":"కంప్యూటర్లు బేస్ 2 మరియు బేస్ 16లో పనిచేస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Everything in assembly language depends on your understanding of these number bases.","translation":"అసెంబ్లీ భాషలో ప్రతిదీ ఈ సంఖ్యా స్థానాల గురించి మీరు అర్థం చేసుకోవడంపై ఆధారపడి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Martians have three fingers on one hand and one on the other.","translation":"అంగారకులకు ఒక చేతికి మూడు వేళ్లు, మరొక చేతికి ఒకటి ఉంటుంది.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Martians started counting by using their fingers.","translation":"అంగారకులు తమ వేళ్లను ఉపయోగించి లెక్కించడం ప్రారంభించారు.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"The Martians used their four fingers to set things off in groups and powers of four.","translation":"అంగారకులు సమూహాలుగా మరియు నాలుగు శక్తులుగా విషయాలను ఏర్పాటు చేయడానికి వారి నాలుగు వేళ్లను ఉపయోగించారు.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"The Martians, similarly, standardized on a set of four digits for their number system.","translation":"అదేవిధంగా, అంగారకులు తమ సంఖ్యా వ్యవస్థ కోసం నాలుగు అంకెల సమితిని ప్రామాణికంగా మార్చారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Like our zero, xip is a placeholder representing no items.","translation":"మన సున్నాలాగానే, xip అనేది ఏ వస్తువులను సూచించని ఒక స్థానాన్ని సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Fooby is the base of the Martian number system.","translation":"ఫూబీ అనేది అంగారక సంఖ్యా వ్యవస్థకు ఆధారం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Fooby is the number of fingers a Martian has.","translation":"ఒక అంగారకుడికి ఎన్ని వేళ్లు ఉన్నాయో ఫూబీ సూచిస్తుంది.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Instead of a single column, fooby is expressed in two columns.","translation":"ఒకే నిలువు వరుసకు బదులుగా, ఫూబీ రెండు నిలువు వరుసలలో వ్యక్తమవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each column has a value that is a power of fooby.","translation":"ప్రతి నిలువు వరుసకు ఫూబీ యొక్క శక్తి విలువ ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The rightmost column represents units, in counts of foo.","translation":"కుడి వైపున ఉన్న నిలువు వరుస యూనిట్లను సూచిస్తుంది, ఫూ గణనలలో.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The second column from the right carries a value of fooby times foo.","translation":"కుడి నుండి రెండవ నిలువు వరుస ఫూబీని ఫూతో గుణించిన విలువను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In a columnar system of numeric notation like both ours and the Martians', the base of the number system is the magnitude by which each column of a number exceeds the magnitude of the column to its right.","translation":"మనది మరియు అంగారకుల సంఖ్యా వ్యవస్థల వంటి నిలువు వరుసల వ్యవస్థలో, సంఖ్యా వ్యవస్థ యొక్క ఆధారం ఏమిటంటే, ఒక సంఖ్య యొక్క ప్రతి నిలువు వరుస దాని కుడి వైపున ఉన్న నిలువు వరుస పరిమాణాన్ని మించిపోతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In our base 10 system, each column represents a value 10 times the column to its right.","translation":"మన బేస్ 10 వ్యవస్థలో, ప్రతి నిలువు వరుస దాని కుడి వైపున ఉన్న నిలువు వరుస కంటే 10 రెట్లు ఎక్కువ విలువను సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In a base fooby system like the one used on Mars, each column represents a value fooby times that of the column to its right.","translation":"అంగారకులలో ఉపయోగించే ఫూబీ వ్యవస్థలో, ప్రతి నిలువు వరుస దాని కుడి వైపున ఉన్న నిలువు వరుస కంటే ఫూబీ రెట్లు ఎక్కువ విలువను సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each has a set of digit symbols, the number of which is equal to the base.","translation":"ప్రతి ఒక్కటి అంకెల చిహ్నాల సమితిని కలిగి ఉంటాయి, వాటి సంఖ్య ఆధారానికి సమానంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In our base 10, we have 10 symbols, from 0 to 9.","translation":"మన బేస్ 10లో, మనకు 0 నుండి 9 వరకు 10 చిహ్నాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In base 4, there are four digits from 0 to 3.","translation":"బేస్ 4లో, 0 నుండి 3 వరకు నాలుగు అంకెలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In any given number base, the base itself can never be expressed in a single digit!","translation":"ఏదైనా సంఖ్యా ఆధారంలో, ఆధారాన్ని ఒక్క అంకెతో ఎప్పుడూ వ్యక్తపరచలేము!","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"She takes a left down to the corner and fills the tank at Del's Shell.","translation":"ఆమె ఎడమవైపు మూలకు వెళ్లి డెల్స్ షెల్ వద్ద ట్యాంక్ నింపుతుంది.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Then, with a full tank, she continues the program by taking a U-turn and heading for Rand Park.","translation":"అప్పుడు, పూర్తి ట్యాంక్తో, ఆమె యు-టర్న్ తీసుకుని రాండ్ పార్క్ వైపు వెళుతూ ప్రోగ్రామ్ను కొనసాగిస్తుంది.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"In the abstract, a test consists of those two parts: First, you take a look at something that can go one of two ways.","translation":"అమూర్తంగా, ఒక పరీక్షలో రెండు భాగాలు ఉంటాయి: మొదట, మీరు రెండు మార్గాల్లో వెళ్ళగలిగే ఒక విషయాన్ని పరిశీలిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Then you do one of two things, depending on what you saw when you took a look.","translation":"అప్పుడు మీరు చూసిన దానిపై ఆధారపడి రెండు విషయాలలో ఒకదాన్ని చేస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Toward the end of the program, our homemaker got home, took the groceries out of the van, and took a look at the clock.","translation":"ప్రోగ్రామ్ ముగింపులో, మా గృహిణి ఇంటికి చేరుకుని, కూరగాయలను వ్యాన్ నుండి తీసి, గడియారాన్ని చూసింది.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"If it isn't time to get Nicky back from Little League, she has a moment to collapse on the couch in a nearly empty house.","translation":"చిన్న లీగ్ నుండి నిక్కీని తిరిగి తీసుకురావడానికి సమయం లేకపోతే, ఆమె దాదాపు ఖాళీగా ఉన్న ఇంట్లో సోఫాలో పడిపోయే సమయం ఉంది.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"If it is time to get Nicky, there's no rest for the ragged: She sprints for the van and heads back to Rand Park.","translation":"నిక్కీని తీసుకువెళ్ళే సమయం అయితే, చిరిగిన వారికి విశ్రాంతి లేదు: ఆమె వ్యాన్ కోసం పరిగెత్తుతుంది మరియు రాండ్ పార్క్ వైపు వెళుతుంది.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"Any guesses as to whether she really gets to collapse when the program is complete?","translation":"ప్రోగ్రామ్ పూర్తయినప్పుడు ఆమె నిజంగా పడిపోతుందా అని ఏమైనా ఊహించగలరా?","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"You might object, saying that many or most tests involve more than two alternatives.","translation":"అనేక లేదా చాలా పరీక్షలు రెండు కంటే ఎక్కువ ప్రత్యామ్నాయాలను కలిగి ఉన్నాయని మీరు అభ్యంతరం చెప్పవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Except for totally impulsive or psychotic behavior, every human decision comes down to the choice between two alternatives.","translation":"పూర్తిగా ప్రేరేపిత లేదా మానసిక స్థితి తప్ప, ప్రతి మానవ నిర్ణయం రెండు ప్రత్యామ్నాయాల మధ్య ఎంపికకు వస్తుంది.","target_lang":"te","domain":"general","complexity":"complex"} | |
| {"en":"The next time you buzz down to Moo Foo Goo for fast Chinese, observe yourself while you're poring over the menu.","translation":"మీరు త్వరగా చైనీస్ కోసం మూ ఫూ గూకి వెళ్ళినప్పుడు, మెనుని పరిశీలిస్తున్నప్పుడు మిమ్మల్ని మీరు గమనించండి.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"The choice might seem, at first, to be of one item out of 26 Cantonese main courses.","translation":"ఎంపిక మొదట 26 కాంటోనీస్ ప్రధాన కోర్సులలో ఒక అంశంగా అనిపించవచ్చు.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"Not so-the choice, in fact, is between choosing one item and not choosing that one item.","translation":"అలా కాదు - వాస్తవానికి ఎంపిక ఒక అంశాన్ని ఎంచుకోవడం మరియు ఆ ఒక్క అంశాన్ని ఎంచుకోకపోవడం మధ్య ఉంటుంది.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"Your eyes rest on Chicken with Cashews.","translation":"మీ కళ్ళు జీడిపప్పుతో చికెన్ మీద విశ్రాంతి తీసుకుంటాయి.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Each dish had its moment, poised before the critical eye of your mind, and you turned thumbs up or thumbs down on it, individually.","translation":"ప్రతి వంటకం దాని క్షణం కలిగి ఉంది, మీ మనస్సు యొక్క క్లిష్టమైన దృష్టి ముందు ఉంచబడింది మరియు మీరు వ్యక్తిగతంగా దానిపై బొటనవేలు పైకి లేదా బొటనవేలు క్రిందికి తిప్పారు.","target_lang":"te","domain":"general","complexity":"complex"} | |
| {"en":"Let me give you another example.","translation":"మరొక ఉదాహరణ ఇస్తాను.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Many of life's most complicated decisions come about due to the fact that 99.99867 percent of us are not nudists.","translation":"మనలో 99.99867 శాతం మంది నగ్నవాదులు కాకపోవడం వల్ల జీవితంలోని చాలా క్లిష్టమైన నిర్ణయాలు వస్తాయి.","target_lang":"te","domain":"general","complexity":"complex"} | |
| {"en":"You've been there: You're standing in the clothes closet in your underwear, flipping through your rack of pants.","translation":"మీరు అక్కడ ఉన్నారు: మీరు మీ లోదుస్తులలో బట్టల బీరువాలో నిలబడి, మీ ప్యాంటు రాక్ ద్వారా తిప్పుతున్నారు.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"The tests come thick and fast.","translation":"పరీక్షలు దట్టంగా మరియు వేగంగా వస్తాయి.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"This one? No. This one? No. This one? Yeah.","translation":"ఇది? లేదు. ఇది? లేదు. ఇది? అవును.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Read that section again, searching for the general method used.","translation":"ఆ భాగాన్ని మళ్ళీ చదవండి, ఉపయోగించిన సాధారణ పద్ధతి కోసం వెతకండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In other words, see what was done and separate the essential principles from any references to a specific base like hex.","translation":"అంటే, ఏమి చేసారో చూడండి మరియు ముఖ్యమైన సూత్రాలను హెచ్ఎక్స్ వంటి నిర్దిష్ట ఆధారాల నుండి వేరు చేయండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"I'll bet by now you can figure it out without much trouble.","translation":"ఇప్పటికే మీరు పెద్దగా శ్రమ లేకుండానే దీన్ని కనుగొనగలరని నేను పందెం కాస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"As a brief aside, perhaps you noticed that I started counting columns from 0 rather than 1.","translation":"ఒక చిన్న విషయం ఏమిటంటే, నేను నిలువు వరుసలను 1 బదులు 0 నుండి లెక్కించడం ప్రారంభించానని మీరు గమనించి ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A peculiarity of the computer field is that we always begin counting things from 0.","translation":"కంప్యూటర్ రంగంలో ఒక ప్రత్యేకత ఏమిటంటే, మనం ఎల్లప్పుడూ విషయాలను 0 నుండి లెక్కించడం ప్రారంభిస్తాము.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Actually, to call it a peculiarity is unfair; the computer's method is the reasonable one, because 0 is a perfectly good number and should not be discriminated against.","translation":"నిజానికి, దీనిని ఒక ప్రత్యేకత అని పిలవడం సరికాదు; కంప్యూటర్ యొక్క పద్ధతి సహేతుకమైనది, ఎందుకంటే 0 ఒక ఖచ్చితమైన మంచి సంఖ్య మరియు వివక్ష చూపకూడదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The rift occurred because in our real, physical world, counting things tells us how many things are there, while in the computer world counting things is more generally done to name them.","translation":"మన నిజమైన, భౌతిక ప్రపంచంలో, విషయాలను లెక్కించడం ద్వారా ఎన్ని విషయాలు ఉన్నాయో తెలుస్తుంది, అయితే కంప్యూటర్ ప్రపంచంలో విషయాలను లెక్కించడం సాధారణంగా వాటిని పేరు పెట్టడానికి జరుగుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"That is, we need to deal with bit number 0, and then bit number 1, and so on, far more than we need to know how many bits there are.","translation":"అంటే, మనం బిట్ నంబర్ 0తో వ్యవహరించాలి, ఆపై బిట్ నంబర్ 1తో వ్యవహరించాలి, మొదలైనవి, ఎన్ని బిట్లు ఉన్నాయో తెలుసుకోవలసిన దానికంటే చాలా ఎక్కువ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is not a quibble, by the way.","translation":"అది ఎలా ఉన్నా ఇది ఒక చిన్న విషయం కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The issue will come up again and again in connection with memory addresses, which as I have said and will say again are the key to understanding assembly language.","translation":"అసెంబ్లీ భాషను అర్థం చేసుకోవడానికి కీలకం అని నేను చెప్పినట్లుగా, మెమరీ చిరునామాలతో సంబంధం ఉన్న సమస్య మళ్ళీ మళ్ళీ వస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In programming circles, always begin counting from 0!","translation":"ప్రోగ్రామింగ్ రంగాలలో, ఎల్లప్పుడూ 0 నుండి లెక్కించడం ప్రారంభించండి!","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A practical example of the conflicts this principle can cause grows out of the following question: What year begins the new millennium?","translation":"ఈ సూత్రం కలిగించే సంఘర్షణలకు సంబంధించిన ఒక ఆచరణాత్మక ఉదాహరణ క్రింది ప్రశ్న నుండి వస్తుంది: కొత్త సహస్రాబ్ది ఏ సంవత్సరంలో ప్రారంభమవుతుంది?","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Most people would intuitively say the year 2000, but technically, the twentieth century will continue until January 1, 2001.","translation":"చాలా మంది సహజంగా 2000 సంవత్సరం అని చెబుతారు, కాని సాంకేతికంగా, ఇరవైయవ శతాబ్దం జనవరి 1, 2001 వరకు కొనసాగుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Why? Because there was no year 0.","translation":"ఎందుకు? ఎందుకంటే 0 సంవత్సరం లేదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When historians count the years moving from B. C. to A. D., they go 1B. C. to 1A. D.","translation":"చరిత్రకారులు B. C. నుండి A. D.కి వెళుతున్న సంవత్సరాలను లెక్కించినప్పుడు, వారు 1B. C. నుండి 1A. D.కి వెళతారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Therefore, the first century began with year 1 and ended with year 100.","translation":"అందువల్ల, మొదటి శతాబ్దం 1వ సంవత్సరంతో ప్రారంభమై 100వ సంవత్సరంతో ముగిసింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The second century began with year 101 and ended with year 200.","translation":"రెండవ శతాబ్దం 101వ సంవత్సరంతో ప్రారంభమై 200వ సంవత్సరంతో ముగిసింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"By extending the sequence you can see that the twentieth century began in 1901 and will end in 2000.","translation":"క్రమాన్ని విస్తరించడం ద్వారా ఇరవైయవ శతాబ్దం 1901లో ప్రారంభమై 2000లో ముగుస్తుందని మీరు చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"On the other hand, if we had had the sense to begin counting years in the current era computer style, from year 0, the twentieth century would end at the end of 1999.","translation":"మరోవైపు, ప్రస్తుత యుగం కంప్యూటర్ శైలిలో సంవత్సరాలను లెక్కించడం ప్రారంభించే తెలివి మనకు ఉంటే, 0 సంవత్సరం నుండి, ఇరవైయవ శతాబ్దం 1999 చివరిలో ముగుస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"My suggestion? Call this the Short Century (which it certainly seems to those of us who have been around for any considerable chunk of it) and begin the Computer Millennium on January 1, 2000.","translation":"నా సలహా? దీనిని షార్ట్ సెంచరీ అని పిలవండి (ఇది ఖచ్చితంగా కొంత భాగాన్ని కలిగి ఉన్న మనకు అనిపిస్తుంది) మరియు జనవరి 1, 2000న కంప్యూటర్ మిలీనియంను ప్రారంభించండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The assembler creates an object file.","translation":"అసెంబ్లర్ ఒక వస్తువు ఫైల్ను సృష్టిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Object files cannot be directly executed.","translation":"వస్తువు ఫైల్లను నేరుగా అమలు చేయలేరు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Linking is necessary to create executable files.","translation":"ఎగ్జిక్యూటబుల్ ఫైల్లను సృష్టించడానికి లింకింగ్ అవసరం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Large source code files can be divided into smaller ones.","translation":"పెద్ద సోర్స్ కోడ్ ఫైల్లను చిన్న వాటిగా విభజించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The assembler assembles the fragments separately.","translation":"అసెంబ్లర్ ముక్కలను వేరుగా అసెంబుల్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Multiple object files are combined into a single executable.","translation":"బహుళ వస్తువు ఫైల్లను ఒకే ఎగ్జిక్యూటబుల్గా కలుపుతారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Linkers are used to create executable program files.","translation":"ఎగ్జిక్యూటబుల్ ప్రోగ్రామ్ ఫైల్లను రూపొందించడానికి లింకర్లను ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can reuse code by linking it into any program.","translation":"మీరు కోడ్ను ఏదైనా ప్రోగ్రామ్లోకి లింక్ చేయడం ద్వారా మళ్లీ ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Tested routines can be moved into separate libraries.","translation":"పరీక్షించిన రొటీన్లను ప్రత్యేక లైబ్రరీలకు తరలించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Assembly language programs create executable files.","translation":"అసెంబ్లీ భాషా ప్రోగ్రామ్లు ఎగ్జిక్యూటబుల్ ఫైల్లను సృష్టిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"DOS has two types of executable program files.","translation":"DOS రెండు రకాల ఎగ్జిక్యూటబుల్ ప్రోగ్రామ్ ఫైల్లను కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":".COM files are produced directly by the assembler.","translation":".COM ఫైల్లను నేరుగా అసెంబ్లర్ ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":".EXE files are generated by a linker.","translation":".EXE ఫైల్లను లింకర్ ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker combines multiple object code files.","translation":"లింకర్ బహుళ వస్తువు కోడ్ ఫైల్లను కలుపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can specify any name you like to the linker.","translation":"మీరు లింకర్కు నచ్చిన పేరును పేర్కొనవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"MASM was a popular assembler for PCs.","translation":"MASM PCల కోసం ఒక ప్రసిద్ధ అసెంబ్లర్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Open source software allows programmers to collaborate.","translation":"ఓపెన్ సోర్స్ సాఫ్ట్వేర్ ప్రోగ్రామర్లను సహకరించడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM is a free and effective assembler.","translation":"NASM ఉచిత మరియు సమర్థవంతమైన అసెంబ్లర్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The error messages may not always be helpful.","translation":"లోపం సందేశాలు ఎల్లప్పుడూ సహాయకరంగా ఉండకపోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Warnings from the assembler can be confusing.","translation":"అసెంబ్లర్ నుండి హెచ్చరికలు గందరగోళంగా ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Information enters the computer through a modem peripheral, which assembles bits received from the telephone line into bytes of data representing characters and numbers.","translation":"ఒక మోడెమ్ పెరిఫెరల్ ద్వారా సమాచారం కంప్యూటర్లోకి ప్రవేశిస్తుంది, ఇది టెలిఫోన్ లైన్ నుండి స్వీకరించబడిన బిట్లను అక్షరాలు మరియు సంఖ్యలను సూచించే డేటా బైట్లుగా మారుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The modem then places the assembled byte onto the bus, from which the CPU picks it up, tallies it, and then places it back on the data bus.","translation":"అసెంబుల్ చేయబడిన బైట్ను మోడెమ్ బస్సులో ఉంచుతుంది, దాని నుండి CPU దానిని తీసుకుంటుంది, లెక్కిస్తుంది మరియు తరువాత దానిని తిరిగి డేటా బస్సులో ఉంచుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The video board then retrieves the byte from the bus and writes it into video memory so that you can see it on your screen.","translation":"వీడియో బోర్డ్ అప్పుడు బస్సు నుండి బైట్ను తిరిగి పొందుతుంది మరియు దానిని వీడియో మెమరీలోకి వ్రాస్తుంది, తద్వారా మీరు దానిని మీ తెరపై చూడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Continuous furious communication along the data bus between CPU, memory, and peripherals is what accomplishes the work that the computer does.","translation":"CPU, మెమరీ మరియు పెరిఫెరల్స్ మధ్య డేటా బస్సు ద్వారా నిరంతర ఉగ్ర కమ్యూనికేషన్ కంప్యూటర్ చేసే పనిని సాధిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The question then arises: Who tells the foreman and crew what to do?","translation":"అప్పుడు ఈ ప్రశ్న తలెత్తుతుంది: సూపరింటెండెంట్ మరియు సిబ్బంది ఏమి చేయాలో ఎవరు చెబుతారు?","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You write a program.","translation":"మీరు ఒక ప్రోగ్రామ్ రాస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"These codes are called machine instructions, and their name is evocative of what they actually are: instructions to the CPU.","translation":"ఈ కోడ్లను మెషిన్ సూచనలు అంటారు మరియు వాటి పేరు వాస్తవానికి అవి ఏమిటో సూచిస్తుంది: CPUకి సూచనలు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Let's take an example or two that is common to all modern CPU chips from Intel.","translation":"ఇంటెల్ నుండి వచ్చిన అన్ని ఆధునిక CPU చిప్లకు సాధారణమైన ఒకటి లేదా రెండు ఉదాహరణలను తీసుకుందాం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The 8-bit binary code 01000000 (40H) means something to the CPU.","translation":"8-బిట్ బైనరీ కోడ్ 01000000 (40H) CPUకి ఏదో అర్థం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It is an order: Add 1 to register AX.","translation":"ఇది ఒక ఆర్డర్: AX రిజిస్టర్కు 1ని జోడించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Most machine instructions occupy more than a single byte.","translation":"చాలా మెషిన్ సూచనలు ఒకే బైట్ కంటే ఎక్కువ ఆక్రమిస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A computer program is nothing more than a table of these machine instructions stored in memory.","translation":"కంప్యూటర్ ప్రోగ్రామ్ అనేది మెమరీలో నిల్వ చేయబడిన ఈ మెషిన్ సూచనల పట్టిక కంటే ఎక్కువ కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the CPU is started running, it fetches a double word (for modern CPUs) from an agreed-upon address in memory.","translation":"CPU రన్ చేయడం ప్రారంభించినప్పుడు, అది మెమరీలో అంగీకరించబడిన చిరునామా నుండి డబుల్ వర్డ్ను (ఆధునిక CPUల కోసం) తెస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU examines the pattern of binary bits contained in the double word, and then begins performing the task that the fetched machine instruction directs it to do.","translation":"CPU డబుల్ వర్డ్లో ఉన్న బైనరీ బిట్ల నమూనాను పరిశీలిస్తుంది, ఆపై తెచ్చిన మెషిన్ సూచన దానిని చేయమని నిర్దేశించిన పనిని చేయడం ప్రారంభిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Inside the CPU is a register called the instruction pointer that quite literally contains the address of the next instruction to be fetched and executed.","translation":"CPU లోపల సూచన పాయింటర్ అని పిలువబడే ఒక రిజిస్టర్ ఉంది, ఇది తదుపరి సూచనను పొందడానికి మరియు అమలు చేయడానికి చిరునామాను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each time an instruction is completed, the instruction pointer is updated to point to the next instruction in memory.","translation":"ఒక సూచన పూర్తయిన ప్రతిసారీ, సూచన పాయింటర్ మెమరీలోని తదుపరి సూచనను సూచించడానికి నవీకరించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Computer programs are lists of binary machine instructions stored in memory.","translation":"కంప్యూటర్ ప్రోగ్రామ్లు మెమరీలో నిల్వ చేయబడిన బైనరీ మెషిన్ సూచనల జాబితాలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"They are no different from any other list of data bytes stored in memory except in how they are treated when fetched by the CPU.","translation":"CPU ద్వారా తెచ్చినప్పుడు వాటిని ఎలా పరిగణిస్తారనే దానిలో తప్ప, అవి మెమరీలో నిల్వ చేయబడిన ఇతర డేటా బైట్ల జాబితా నుండి భిన్నంగా ఉండవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU works its way through memory, with the instruction pointer register leading the way.","translation":"CPU సూచన పాయింటర్ రిజిస్టర్తో మెమరీ ద్వారా తన మార్గాన్ని నడిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU can change its course of execution based on the work it has been doing.","translation":"CPU తాను చేస్తున్న పని ఆధారంగా దాని అమలు మార్గాన్ని మార్చుకోగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A DOS file contains some number of bytes, stored in a specific order.","translation":"DOS ఫైల్లో కొన్ని బైట్లు ఉంటాయి, అవి ఒక నిర్దిష్ట క్రమంలో నిల్వ చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Data is stored as little magnetic disturbances on the plastic coating.","translation":"డేటా ప్లాస్టిక్ పూతపై చిన్న అయస్కాంత అంతరాయాలుగా నిల్వ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A sensor called a read/write head sits very close beside the rotating platform.","translation":"రీడ్/రైట్ హెడ్ అనే సెన్సార్ తిరిగే వేదిక పక్కన చాలా దగ్గరగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The tracks are further divided radially into sectors.","translation":"ట్రాక్లు మరింత రేడియల్గా సెక్టార్లుగా విభజించబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A sector is the smallest unit of storage that can be read or written at one time.","translation":"ఒక సెక్టార్ అనేది ఒకే సమయంలో చదవడానికి లేదా వ్రాయడానికి వీలయ్యే అతి చిన్న నిల్వ యూనిట్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A DOS disk file consists of one or more sectors containing the file's data.","translation":"DOS డిస్క్ ఫైల్ ఫైల్ డేటాను కలిగి ఉన్న ఒకటి లేదా అంతకంటే ఎక్కువ సెక్టార్లను కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The read/write head is mounted on a sliding shaft that is controlled by a solenoid mechanism.","translation":"రీడ్/రైట్ హెడ్ ఒక స్లైడింగ్ షాఫ్ట్పై అమర్చబడి ఉంటుంది, ఇది సోలేనాయిడ్ మెకానిజం ద్వారా నియంత్రించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Programs can hand sectors of data to DOS, one at a time.","translation":"ప్రోగ్రామ్లు డేటా యొక్క సెక్టార్లను DOSకి ఒక్కొక్కటిగా అందించగలవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each sector has a number, and DOS keeps track of what sectors belong together as a file.","translation":"ప్రతి సెక్టార్కు ఒక సంఖ్య ఉంటుంది మరియు ఒక ఫైల్గా ఏ సెక్టార్లు కలిసి ఉన్నాయో DOS ట్రాక్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The data stored in a file are just binary bytes and can be anything at all.","translation":"ఒక ఫైల్లో నిల్వ చేయబడిన డేటా కేవలం బైనరీ బైట్లు మరియు ఏదైనా కావచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Files like this, where there are no restrictions on the contents of a file, are called binary files.","translation":"ఒక ఫైల్ యొక్క విషయాలపై ఎటువంటి పరిమితులు లేని ఇలాంటి ఫైల్లను బైనరీ ఫైల్లు అంటారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A binary file has no structure, but is simply a long series of binary codes.","translation":"బైనరీ ఫైల్కు నిర్మాణం లేదు, కానీ ఇది కేవలం బైనరీ కోడ్ల యొక్క పొడవైన శ్రేణి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If you've ever tried to use the DOS TYPE command to display a binary file, you've seen some odd things indeed.","translation":"మీరు ఎప్పుడైనా బైనరీ ఫైల్ను ప్రదర్శించడానికి DOS TYPE కమాండ్ ఉపయోగించడానికి ప్రయత్నిస్తే, మీరు కొన్ని విచిత్రమైన విషయాలను చూసి ఉంటారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"These are text files, because they contain the letters, digits, and symbols of which printed human information (text) is composed.","translation":"ఇవి టెక్స్ట్ ఫైల్లు, ఎందుకంటే అవి అక్షరాలు, అంకెలు మరియు చిహ్నాలను కలిగి ఉంటాయి, వీటితో ముద్రిత మానవ సమాచారం (టెక్స్ట్) ఏర్పడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A line in a text file is defined not so much by what it contains as by how it ends.","translation":"టెక్స్ట్ ఫైల్లోని ఒక లైన్ అది కలిగి ఉన్న దానికంటే ఎక్కువగా అది ఎలా ముగుస్తుందో దాని ద్వారా నిర్వచించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A special series of invisible characters called an end-of-line (EOL) marker tags the end of a line.","translation":"ఎండ్-ఆఫ్-లైన్ (EOL) మార్కర్ అని పిలువబడే ప్రత్యేక శ్రేణి అదృశ్య అక్షరాలు ఒక లైన్ ముగింపును గుర్తిస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The EOL marker for DOS is not one character but two: the carriage return character followed by the linefeed character.","translation":"DOS కోసం EOL మార్కర్ ఒక అక్షరం కాదు, రెండు: క్యారేజ్ రిటర్న్ అక్షరం తరువాత లైన్ఫీడ్ అక్షరం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"With Linux things are different: a single LF, without a partner CR.","translation":"Linuxతో విషయాలు భిన్నంగా ఉంటాయి: ఒకే LF, భాగస్వామి CR లేకుండా.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Assembly language is a translator language that allows total control over every individual machine instruction.","translation":"అసెంబ్లీ భాష అనేది ఒక అనువాద భాష, ఇది ప్రతి వ్యక్తిగత మెషిన్ సూచనపై పూర్తి నియంత్రణను అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"An assembler is a special type of compiler.","translation":"అసెంబ్లర్ ఒక ప్రత్యేక రకం కంపైలర్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Early months of 2000, you can purchase these little circuit board memory sticks (called SIMMs, for Single Inline Memory Module) with as much as 128 megabytes in them.","translation":"2000 సంవత్సరం ప్రారంభ నెలల్లో, మీరు 128 మెగాబైట్ల వరకు ఉండే చిన్న సర్క్యూట్ బోర్డ్ మెమరీ స్టిక్లను (సిమ్స్, సింగిల్ ఇన్లైన్ మెమరీ మాడ్యూల్ కోసం) కొనుగోలు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Will it stop here? Unlikely.","translation":"ఇక్కడితో ఆగిపోతుందా? అవకాశం లేదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"More is better, and we're bringing some staggeringly powerful technology to bear on the creation of ever-denser memory systems.","translation":"మరింత మంచిది, మరియు మేము ఎప్పటికప్పుడు దట్టమైన మెమరీ సిస్టమ్లను రూపొందించడానికి అద్భుతమైన శక్తివంతమైన సాంకేతికతను ఉపయోగిస్తున్నాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Some physicists warn that the laws of physics may soon call a time-out in the game.","translation":"కొంతమంది భౌతిక శాస్త్రవేత్తలు భౌతిక శాస్త్ర నియమాలు త్వరలో ఆటలో సమయం ముగింపును పిలుస్తాయని హెచ్చరిస్తున్నారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"At that point some truly ugly limitations of life called quantum mechanics begin to get in the way.","translation":"ఆ సమయంలో క్వాంటం మెకానిక్స్ అని పిలువబడే జీవితంలోని కొన్ని నిజంగా అసహ్యకరమైన పరిమితులు మార్గంలోకి రావడం ప్రారంభిస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"We'll find a way around these limitations (we always do), but in the process the whole nature of computer memory may change.","translation":"మేము ఈ పరిమితుల చుట్టూ ఒక మార్గాన్ని కనుగొంటాము (మేము ఎల్లప్పుడూ చేస్తాము), కానీ ఈ ప్రక్రియలో కంప్యూటర్ మెమరీ యొక్క మొత్తం స్వభావం మారవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"For now, what we have are billion-bit memory sticks.","translation":"ఇప్పుడు, మన దగ్గర ఉన్నవి బిలియన్-బిట్ మెమరీ స్టిక్స్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"My computer here has two of them, for a total of 256 megabytes of electronic memory.","translation":"నా కంప్యూటర్లో రెండు ఉన్నాయి, మొత్తం 256 మెగాబైట్ల ఎలక్ట్రానిక్ మెమరీ ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"That should hold me until next week, heh-heh.","translation":"అది వచ్చే వారం వరకు నన్ను ఉంచుతుంది, హేహ్-హేహ్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"These chips are called RAM chips, since what they contain is random-access memory.","translation":"ఈ చిప్లను RAM చిప్లు అంటారు, ఎందుకంటే వాటిలో ఉండేది యాదృచ్ఛిక-యాక్సెస్ మెమరీ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Newcomers sometimes find this a perplexing and disturbing word, since random often connotes chaos or unpredictability.","translation":"కొత్తగా వచ్చినవారు దీనిని గందరగోళంగా మరియు కలవరపరిచే పదంగా భావిస్తారు, ఎందుకంటే యాదృచ్ఛికంగా తరచుగా గందరగోళం లేదా ఊహించలేనిదిగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"What the word really means is \"at random,\" indicating that you can reach into a random-access memory chip and pick out any of the bits it contains without disturbing any of the others.","translation":"పదం యొక్క అర్థం నిజంగా \"యాదృచ్ఛికంగా,\" అంటే మీరు యాదృచ్ఛిక-యాక్సెస్ మెమరీ చిప్లోకి చేరుకుని, ఇతరులను కలవరపరచకుండా అందులోని ఏ బిట్నైనా ఎంచుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Memory didn't always work this way.","translation":"మెమరీ ఎల్లప్పుడూ ఈ విధంగా పనిచేయలేదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Before memory was placed on silicon chips, it was stored on magnetic gadgets of some kind, usually rotating drums or disks distantly related to the hard drives we use today.","translation":"మెమరీని సిలికాన్ చిప్లపై ఉంచడానికి ముందు, అది కొన్ని రకాల అయస్కాంత పరికరాలపై నిల్వ చేయబడింది, సాధారణంగా మనం ఈరోజు ఉపయోగించే హార్డ్ డ్రైవ్లకు దూరంగా సంబంధం ఉన్న తిరిగే డ్రమ్స్ లేదా డిస్క్లు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Rotating memory sends a circular collection of bits beneath a magnetic sensor.","translation":"తిరిగే మెమరీ అయస్కాంత సెన్సార్ కింద బిట్స్ యొక్క వృత్తాకార సేకరణను పంపుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The bits pass beneath the sensor one at a time, and if you miss the one you want, like a Chicago bus in January, you simply have to wait for it to come by again.","translation":"బిట్స్ సెన్సార్ కింద ఒకేసారి వెళతాయి, మరియు మీరు కోరుకున్నదాన్ని కోల్పోతే, జనవరిలో చికాగో బస్సులా, మీరు అది మళ్లీ వచ్చే వరకు వేచి ఉండాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"These are serial-access devices.","translation":"ఇవి సీరియల్-యాక్సెస్ పరికరాలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"They present their bits to you, in a fixed order, one at a time, and you have to wait for the one you want to come up in its order.","translation":"అవి మీ బిట్లను ఒక నిర్దిష్ట క్రమంలో, ఒకేసారి అందిస్తాయి మరియు మీరు కోరుకున్నది దాని క్రమంలో వచ్చే వరకు మీరు వేచి ఉండాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"No need to remember that; we've long since abandoned serial-access devices for main computer memory.","translation":"అది గుర్తుంచుకోవాల్సిన అవసరం లేదు; మేము ప్రధాన కంప్యూటర్ మెమరీ కోసం సీరియల్-యాక్సెస్ పరికరాలను చాలా కాలం క్రితమే వదిలివేశాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"We still use such systems for mass storage, as I describe a few pages down the road.","translation":"కొన్ని పేజీల తర్వాత నేను వివరించిన విధంగా, మేము ఇప్పటికీ భారీ నిల్వ కోసం అలాంటి వ్యవస్థలను ఉపయోగిస్తాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You cannot continue until the assembler gives your source code file a clean bill of health.","translation":"అసెంబ్లర్ మీ సోర్స్ కోడ్ ఫైల్కు ఆరోగ్యకరమైన బిల్లును అందించే వరకు మీరు కొనసాగించలేరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker performs a number of operations on the . OBJ file, most of which would be meaningless to you at this point.","translation":" లింకర్ .OBJ ఫైల్పై అనేక కార్యకలాపాలను నిర్వహిస్తుంది, వాటిలో చాలా వరకు ఈ సమయంలో మీకు అర్ధం లేనివిగా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Creating an assembly language program from multiple . ASM files is called modular assembly.","translation":"అనేక .ASM ఫైల్ల నుండి అసెంబ్లీ భాషా ప్రోగ్రామ్ను సృష్టించడాన్ని మాడ్యులర్ అసెంబ్లీ అంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One of two major reasons is size.","translation":"రెండు ప్రధాన కారణాలలో ఒకటి పరిమాణం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Cutting that single monolithic . ASM file up into multiple 8,000-line . ASM files would make the individual . ASM files smaller and much easier to understand.","translation":"ఒకే మోనోలిథిక్ .ASM ఫైల్ను బహుళ 8,000-లైన్ .ASM ఫైల్లుగా విభజించడం వలన వ్యక్తిగత .ASM ఫైల్లు చిన్నవిగా మరియు అర్థం చేసుకోవడానికి చాలా సులభంగా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Once you write and perfect a procedure, you can tuck it away in an . ASM file with other completed procedures.","translation":"మీరు ఒక విధానాన్ని వ్రాసి, పూర్తి చేసిన తర్వాత, మీరు దానిని ఇతర పూర్తి చేసిన విధానాలతో .ASM ఫైల్లో దాచవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The alternative is to waste time by reassembling perfected source code over and over again every time you assemble the main portion of the program.","translation":"ప్రత్యామ్నాయం ఏమిటంటే, ప్రోగ్రామ్ యొక్క ప్రధాన భాగాన్ని అసెంబ్లీ చేసిన ప్రతిసారీ, పరిపూర్ణమైన సోర్స్ కోడ్ను పదేపదే మళ్లీ అసెంబ్లీ చేయడం ద్వారా సమయాన్ని వృధా చేయడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When the linker links the . OBJ file produced from your in- progress . ASM file, it adds in the previously assembled . OBJ files, which are called modules.","translation":"లింకర్ మీ పురోగతిలో ఉన్న .ASM ఫైల్ నుండి ఉత్పత్తి చేయబడిన .OBJ ఫైల్ను లింక్ చేసినప్పుడు, ఇది ఇంతకు ముందు అసెంబ్లీ చేయబడిన .OBJ ఫైల్లను జోడిస్తుంది, వీటిని మాడ్యూల్స్ అంటారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A very important bonus is that some of the procedures in an . OBJ module may be used in a future assembly language program that hasn't even been begun yet.","translation":"ఒక ముఖ్యమైన బోనస్ ఏమిటంటే, .OBJ మాడ్యూల్లోని కొన్ని విధానాలను భవిష్యత్తులో అసెంబ్లీ భాషా ప్రోగ్రామ్లో ఉపయోగించవచ్చు, అది ఇంకా ప్రారంభించబడలేదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Creating such libraries of \"toolkit\" procedures can be an extraordinarily effective way to save time by reusing code over and over again, without even passing it through the assembler again!","translation":"\"టూల్కిట్\" విధానాల యొక్క అలాంటి లైబ్రరీలను సృష్టించడం కోడ్ను పదేపదే తిరిగి ఉపయోగించడం ద్వారా సమయాన్ని ఆదా చేయడానికి అసాధారణంగా ప్రభావవంతమైన మార్గం కావచ్చు, అసెంబ్లర్ను మళ్లీ దాటకుండా!","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"But keep in mind that to produce an executable . EXE file from multiple assembly language source code files, you must invoke the linker.","translation":"కానీ బహుళ అసెంబ్లీ భాషా సోర్స్ కోడ్ ఫైల్ల నుండి ఎగ్జిక్యూటబుల్ .EXE ఫైల్ను ఉత్పత్తి చేయడానికి, మీరు లింకర్ను పిలవాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker I discuss in this book is called ALINK.","translation":"నేను ఈ పుస్తకంలో చర్చించే లింకర్ ALINK అని పిలువబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Invoking the linker is again done from the DOS command line.","translation":"లింకర్ను పిలవడం మళ్లీ DOS కమాండ్ లైన్ నుండి చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"With ALINK, you simply name each . OBJ file on the command line after the word ALINK, with a space between each file name.","translation":"ALINKతో, మీరు ప్రతి .OBJ ఫైల్ను ALINK అనే పదం తర్వాత కమాండ్ లైన్లో పేర్కొనండి, ప్రతి ఫైల్ పేరు మధ్య స్పేస్ ఇవ్వండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Linker errors are subtler than assembler errors and are usually harder to find.","translation":"లింకర్ లోపాలు అసెంబ్లర్ లోపాల కంటే సూక్ష్మంగా ఉంటాయి మరియు సాధారణంగా కనుగొనడం కష్టం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"As with assembler errors, when you are presented with a linker error you have to return to the editor and figure out what the problem is.","translation":"అసెంబ్లర్ లోపాలతో పాటు, మీకు లింకర్ లోపం వచ్చినప్పుడు, మీరు ఎడిటర్కు తిరిగి వెళ్లి సమస్య ఏమిటో తెలుసుకోవాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If you receive no linker errors, the linker will create and fill a single . EXE file with the machine instructions present in all of the . OBJ files named on the linker command line.","translation":"మీకు లింకర్ లోపాలు రాకపోతే, లింకర్ లింకర్ కమాండ్ లైన్లో పేర్కొనబడిన అన్ని .OBJ ఫైల్లలో ఉన్న మెషిన్ సూచనలతో ఒకే .EXE ఫైల్ను సృష్టిస్తుంది మరియు నింపుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A bug is anything in a program that doesn't work the way you want it to.","translation":"మీరు కోరుకున్న విధంగా పని చేయని ప్రోగ్రామ్లోని ఏదైనా ఒక లోపం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A system crash is what you call it when the machine sits there mutely and will not respond to the keyboard.","translation":"మెషిన్ మూగగా కూర్చుని కీబోర్డ్కు స్పందించనప్పుడు మీరు దానిని సిస్టమ్ క్రాష్ అని పిలుస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A serious and ambitious application could take weeks-or months-to test thoroughly.","translation":"ఒక తీవ్రమైన మరియు ప్రతిష్టాత్మకమైన అప్లికేషన్ పూర్తిగా పరీక్షించడానికి వారాలు లేదా నెలలు పట్టవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"I recommend that you place the directory containing NASM-IDE on your DOS path.","translation":"NASM-IDE ఉన్న డైరెక్టరీని మీ DOS మార్గంలో ఉంచాలని నేను సిఫార్సు చేస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"That way, no matter where you are on your hard drive, you can type \"NASMIDE\" and NASM-IDE will come up, ready for work.","translation":"అలా చేయడం ద్వారా, మీరు మీ హార్డ్ డ్రైవ్లో ఎక్కడ ఉన్నా, మీరు \"NASMIDE\" అని టైప్ చేయవచ్చు మరియు NASM-IDE పని చేయడానికి సిద్ధంగా వస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When you bring up NASM-IDE using the preceding command line, what you'll see should look a lot like Figure 5.1.","translation":"మునుపటి కమాండ్ లైన్ని ఉపయోగించి మీరు NASM-IDEని తెచ్చినప్పుడు, మీరు చూసేది చాలా వరకు చిత్రం 5.1 వలె ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM-IDE consists of an empty space (with a texture to fill it, indicating that it's empty) in which you can open windows containing information.","translation":"NASM-IDE ఖాళీ స్థలం (దానిని నింపడానికి ఒక ఆకృతితో, అది ఖాళీగా ఉందని సూచిస్తుంది) కలిగి ఉంటుంది, దీనిలో మీరు సమాచారాన్ని కలిగి ఉన్న విండోలను తెరవవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"At the top of the screen is a menu bar.","translation":"స్క్రీన్ పైభాగంలో మెనూ బార్ ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"At the bottom of the screen is a prompt bar.","translation":"స్క్రీన్ దిగువన ఒక ప్రాంప్ట్ బార్ ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The menu bar provides several menus of options that you can pull down (either from the keyboard or with the mouse) to accomplish the various things that NASM-IDE can do.","translation":"మెనూ బార్ మీరు వివిధ పనులను చేయడానికి (కీబోర్డ్ నుండి లేదా మౌస్తో) లాగగల అనేక ఎంపికల మెనూలను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The prompt bar gives you terse reminders of the most important commands that you can issue via the function keys and various hot keys.","translation":"ప్రాంప్ట్ బార్ ఫంక్షన్ కీలు మరియు వివిధ హాట్ కీలను ఉపయోగించి మీరు జారీ చేయగల అత్యంత ముఖ్యమైన ఆదేశాల గురించి క్లుప్త రిమైండర్లను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Square in the middle of the screen is an edit window containing the file you opened when you invoked NASM-IDE.","translation":"స్క్రీన్ మధ్యలో ఉన్న చతురస్రం మీరు NASM-IDEని ప్రారంభించినప్పుడు మీరు తెరిచిన ఫైల్ను కలిగి ఉన్న ఎడిట్ విండో.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There isn't a lot of installing or configuring to be done with either NASMIDE or NASM itself.","translation":"NASMIDE లేదా NASMతో చాలా ఇన్స్టాలేషన్ లేదా కాన్ఫిగరేషన్ చేయడానికి ఏమీ లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"However, you need to copy that directory to a place on your hard drive, because you cannot write files to the CD-ROM.","translation":"అయితే, మీరు ఆ డైరెక్టరీని మీ హార్డ్ డ్రైవ్లోని ఒక ప్రదేశానికి కాపీ చేయాలి, ఎందుకంటే మీరు CD-ROMకి ఫైల్లను వ్రాయలేరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can drag the ASM directory from the CD-ROM to one of your hard drive units using Windows Explorer, and all of the subdirectories under ASM will come along.","translation":"మీరు విండోస్ ఎక్స్ప్లోరర్ని ఉపయోగించి CD-ROM నుండి ASM డైరెక్టరీని మీ హార్డ్ డ్రైవ్ యూనిట్లలో ఒకదానికి లాగవచ్చు మరియు ASM కింద ఉన్న అన్ని సబ్డైరెక్టరీలు వస్తాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Once you get NASM-IDE running, you need to do one essential piece of configuration before you can use it: You must tell it the exact path where the NASM executable file resides.","translation":"మీరు NASM-IDEని రన్ చేసిన తర్వాత, మీరు దీన్ని ఉపయోగించే ముందు ఒక ముఖ్యమైన కాన్ఫిగరేషన్ చేయాలి: NASM ఎగ్జిక్యూటబుల్ ఫైల్ ఉన్న ఖచ్చితమైన మార్గాన్ని మీరు చెప్పాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"I recommend making ASM a subdirectory on the root of one of your hard drives; for example, C:\\ASM rather than C:\\programming\\ASM.","translation":"మీ హార్డ్ డ్రైవ్లలో ఒకదాని రూట్లో ASMని ఒక సబ్డైరెక్టరీగా మార్చమని నేను సిఫార్సు చేస్తున్నాను; ఉదాహరణకు, C:\\programming\\ASMకి బదులుగా C:\\ASM.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Choose one and copy the ASM directory from your CD-ROM to your hard drive.","translation":"ఒకదాన్ని ఎంచుకుని, మీ CD-ROM నుండి ASM డైరెక్టరీని మీ హార్డ్ డ్రైవ్కు కాపీ చేయండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Then bring up NASM-IDE and pull down the Options menu.","translation":"ఆపై NASM-IDEని తీసుకురండి మరియు ఎంపికల మెనుని లాగండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Select the Options|Assembler item by either highlighting it and pressing Enter, or double-clicking on it with your mouse.","translation":"దీన్ని హైలైట్ చేసి ఎంటర్ నొక్కడం ద్వారా లేదా మీ మౌస్తో డబుల్ క్లిక్ చేయడం ద్వారా ఎంపికలు|అసెంబ్లర్ అంశాన్ని ఎంచుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A dialog box will appear.","translation":"ఒక డైలాగ్ బాక్స్ కనిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You shouldn't change anything in this box except for one item: the edit line labeled NASM Location.","translation":"ఒక అంశం తప్ప మీరు ఈ పెట్టెలో దేనినీ మార్చకూడదు: NASM స్థానం అని లేబుల్ చేయబడిన ఎడిట్ లైన్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the dialog box appears, this line will be blank.","translation":"డైలాగ్ బాక్స్ కనిపించినప్పుడు, ఈ లైన్ ఖాళీగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Fixing it, however, is easy.","translation":"అయితే, దీన్ని పరిష్కరించడం సులభం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Assembly language is nothing if not tricky.","translation":"అసెంబ్లీ భాష కష్టతరమైనది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You have to be able to identify errors based on what you've written.","translation":"మీరు వ్రాసిన దాని ఆధారంగా లోపాలను గుర్తించగలగాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM-IDE has the error dead to rights, and you can fix the error by nuking the whole line with a quick Ctrl-Y.","translation":"NASM-IDE లోపాన్ని సరిగ్గా గుర్తించింది, మరియు మీరు Ctrl-Y నొక్కడం ద్వారా మొత్తం లైన్ను తొలగించడం ద్వారా లోపాన్ని పరిష్కరించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Every time you assemble, the error information message will appear, either with this message-or with an error message or a warning.","translation":"మీరు అసెంబుల్ చేసిన ప్రతిసారీ, లోపం సమాచార సందేశం కనిపిస్తుంది, ఈ సందేశంతో లేదా లోపం సందేశంతో లేదా హెచ్చరికతో.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can run the EAT2. COM file from the DOS prompt, just like you can run any . COM or . EXE file from the DOS prompt.","translation":"మీరు DOS ప్రాంప్ట్ నుండి ఏదైనా .COM లేదా .EXE ఫైల్ను అమలు చేసినట్లే, మీరు EAT2.COM ఫైల్ను DOS ప్రాంప్ట్ నుండి అమలు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM-IDE can run your executable program file for you, right from inside NASM-IDE.","translation":"NASM-IDE లోపల నుండే మీ ఎగ్జిక్యూటబుల్ ప్రోగ్రామ్ ఫైల్ను NASM-IDE అమలు చేయగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM-IDE will go away for a moment, and instead you'll see a blank DOS screen with the output of your program on it.","translation":"NASM-IDE కొంత సమయం కోసం అదృశ్యమవుతుంది, మరియు బదులుగా మీ ప్రోగ్రామ్ యొక్క అవుట్పుట్తో ఖాళీ DOS స్క్రీన్ను మీరు చూస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Getting back to NASM-IDE is no big deal: Just do as the screen instructs you, and press any key.","translation":"NASM-IDEకి తిరిగి వెళ్లడం పెద్ద విషయం కాదు: స్క్రీన్ మీకు సూచించిన విధంగా చేయండి మరియు ఏదైనా కీని నొక్కండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"People who have read earlier editions of this book may notice a remarkable resemblance between NASM-IDE's text window and my own JED editor.","translation":"ఈ పుస్తకం యొక్క మునుపటి ఎడిషన్లను చదివిన వారు NASM-IDE యొక్క టెక్స్ట్ విండో మరియు నా స్వంత JED ఎడిటర్ మధ్య ఉన్న అద్భుతమైన పోలికను గమనించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Individual lines within an edit file are limited to 254 characters.","translation":"ఒక ఎడిట్ ఫైల్లోని వ్యక్తిగత లైన్లు 254 అక్షరాలకు పరిమితం చేయబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Loading a file with longer lines will cause the editor to insert hyphens at the 254-character point.","translation":"ఎక్కువ లైన్లతో ఫైల్ను లోడ్ చేయడం వలన ఎడిటర్ 254-అక్షరాల పాయింట్ వద్ద హైఫన్లను చొప్పిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You'll get an error box if you try to type past the 254-character point on any line.","translation":"మీరు ఏదైనా లైన్లో 254-అక్షరాల పాయింట్ దాటి టైప్ చేయడానికి ప్రయత్నిస్తే, మీకు లోపం బాక్స్ వస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Although it's not something you'll do a lot, it's useful to know that you can load more than one text file into NASM-IDE's environment at once.","translation":"మీరు చాలా చేయకపోయినా, ఒకేసారి NASM-IDE యొక్క పరిసరాలలో ఒకటి కంటే ఎక్కువ టెక్స్ట్ ఫైల్లను లోడ్ చేయవచ్చని తెలుసుకోవడం ఉపయోగకరంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Opening a file in an edit window from inside NASM-IDE is done using either the menus or hotkeys.","translation":"NASM-IDE లోపల నుండి ఎడిట్ విండోలో ఫైల్ను తెరవడం మెనూలు లేదా హాట్కీలను ఉపయోగించి చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Selecting the File|Open menu item with the mouse will bring up a dialog box that will allow you to specify the file you want to open.","translation":"మౌస్తో ఫైల్|ఓపెన్ మెను ఐటెమ్ను ఎంచుకోవడం ద్వారా మీరు తెరవాలనుకుంటున్న ఫైల్ను పేర్కొనడానికి మిమ్మల్ని అనుమతించే డైలాగ్ బాక్స్ వస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The same dialog box can be invoked with the F3 hot key.","translation":"అదే డైలాగ్ బాక్స్ను F3 హాట్ కీతో పిలవవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Like all parts of NASM-IDE, the dialog box allows you to work either with the mouse or purely from the keyboard.","translation":"NASM-IDE యొక్క అన్ని భాగాల వలె, డైలాగ్ బాక్స్ మౌస్తో లేదా పూర్తిగా కీబోర్డ్ నుండి పని చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Most people have a mouse, so I'll emphasize mouse-enabled techniques in my explanations.","translation":"చాలా మందికి మౌస్ ఉంది, కాబట్టి నా వివరణలలో మౌస్-ఎనేబుల్ చేయబడిన పద్ధతులను నేను నొక్కి చెబుతాను.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You can navigate through a DOS directory structure using the dialog box.","translation":"మీరు డైలాగ్ బాక్స్ని ఉపయోగించి DOS డైరెక్టరీ నిర్మాణంలో నావిగేట్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Anything after that final 0AH value is garbage in memory and not part of the file!","translation":"ఆఖరి 0AH విలువ తర్వాత ఏదైనా మెమరీలో చెత్తగా ఉంటుంది మరియు ఫైల్ లో భాగం కాదు!","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"So, it matters where the end of the file is.","translation":"కాబట్టి, ఫైల్ ముగింపు ఎక్కడ ఉందో అది ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Some very old DOS text editors appended a single invisible byte at the end of every text file they wrote to disk.","translation":"కొన్ని చాలా పాత DOS టెక్స్ట్ ఎడిటర్లు వారు డిస్క్కు వ్రాసిన ప్రతి టెక్స్ట్ ఫైల్ చివరన ఒకే అదృశ్య బైట్ను జోడించాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This byte, 1AH, was intended as a marker to show you very clearly where the end of the file was.","translation":"ఈ బైట్, 1AH, ఫైల్ ముగింపు ఎక్కడ ఉందో మీకు చాలా స్పష్టంగా చూపించడానికి ఒక గుర్తుగా ఉద్దేశించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Some of these text editors are still kicking around, and it's possible that you have one.","translation":"ఈ టెక్స్ట్ ఎడిటర్లలో కొన్ని ఇప్పటికీ వాడుకలో ఉన్నాయి మరియు మీ దగ్గర ఒకటి ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"(To see if you do, type in a simple sentence like \"Where will it all end?\" and save to disk.","translation":"మీరు కలిగి ఉన్నారో లేదో తెలుసుకోవడానికి, \"అంతా ఎక్కడ ముగుస్తుంది?\" వంటి సాధారణ వాక్యాన్ని టైప్ చేసి డిస్క్కు సేవ్ చేయండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Go in with debug and see if there is a 1AH byte immediately after the end of the sentence.)","translation":"డీబగ్ చేసి, వాక్యం ముగిసిన వెంటనే 1AH బైట్ ఉందో లేదో చూడండి.)","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The 1AH marker is a holdover from even more ancient times, from the CP/M operating system, which was simpler than DOS and remembered only the number of disk storage blocks a file occupied.","translation":"1AH మార్కర్ అనేది మరింత పురాతన కాలం నుండి, CP/M ఆపరేటింగ్ సిస్టమ్ నుండి వచ్చినది, ఇది DOS కంటే సరళమైనది మరియు ఫైల్ ఆక్రమించిన డిస్క్ నిల్వ బ్లాక్ల సంఖ్యను మాత్రమే గుర్తుంచుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The precise byte where the file's data ended within the final block was unknown to CP/M, so the text editors of the time used a 1AH byte to mark the tail end of the file.","translation":"చివరి బ్లాక్లో ఫైల్ డేటా ముగిసిన ఖచ్చితమైన బైట్ CP/Mకి తెలియదు, కాబట్టి ఆ సమయంలోని టెక్స్ట్ ఎడిటర్లు ఫైల్ యొక్క తోక చివరను గుర్తించడానికి 1AH బైట్ను ఉపయోగించాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"There's a file on your CD-ROM, OLDSAM. TXT, which was created with such a text editor and has the final 1AH marker.","translation":"మీ CD-ROMలో OLDSAM. TXT అనే ఫైల్ ఉంది, ఇది అలాంటి టెక్స్ట్ ఎడిటర్తో సృష్టించబడింది మరియు చివరి 1AH మార్కర్ను కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"(Note the time stamp on OLDSAM. TXT!)","translation":"(OLDSAM. TXTపై ఉన్న టైమ్ స్టాంప్ను గమనించండి!)","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"OLDSAM is otherwise identical to SAM. TXT.","translation":"OLDSAM ఇతరత్రా SAM. TXT వలెనే ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Note that when you do a DOS DIR command on the directory containing the two files, that OLDSAM. TXT is 20 bytes long-the 1AH marker byte is considered part of the file and counted with all the rest of the data.","translation":"రెండు ఫైల్లను కలిగి ఉన్న డైరెక్టరీలో మీరు DOS DIR కమాండ్ చేసినప్పుడు, OLDSAM. TXT 20 బైట్ల పొడవు ఉంటుందని గమనించండి - 1AH మార్కర్ బైట్ ఫైల్లో భాగంగా పరిగణించబడుతుంది మరియు మిగిలిన డేటాతో లెక్కించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Most of the time, memory garbage is not entirely random, but instead may be part of the code or data left over from the last program to be loaded and executed in that area of memory.","translation":"చాలా సమయం, మెమరీ చెత్త పూర్తిగా యాదృచ్ఛికంగా ఉండదు, కానీ బదులుగా మెమరీ యొక్క ఆ ప్రాంతంలో లోడ్ చేయబడిన మరియు అమలు చేయబడిన చివరి ప్రోగ్రామ్ నుండి మిగిలిపోయిన కోడ్ లేదా డేటాలో భాగంగా ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"You can safely ignore memory garbage, but should know what it is and why it appears in your hex dumps.","translation":"మీరు మెమరీ చెత్తను సురక్షితంగా విస్మరించవచ్చు, కానీ అది ఏమిటో మరియు మీ హెచ్ఎక్స్ డంప్లలో ఎందుకు కనిపిస్తుందో తెలుసుకోవాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You might occasionally see recognizable data strings from other programs in memory garbage and wonder how they got into your current program.","translation":"మీరు అప్పుడప్పుడు ఇతర ప్రోగ్రామ్ల నుండి గుర్తించదగిన డేటా స్ట్రింగ్లను మెమరీ చెత్తలో చూడవచ్చు మరియు అవి మీ ప్రస్తుత ప్రోగ్రామ్లోకి ఎలా వచ్చాయో ఆశ్చర్యపోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Note well: They didn't get into your current program.","translation":"బాగా గమనించండి: అవి మీ ప్రస్తుత ప్రోగ్రామ్లోకి రాలేదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"They were just there, and now show through beyond the end of the file you last loaded under DEBUG.","translation":"అవి అక్కడ ఉన్నాయి, మరియు ఇప్పుడు మీరు చివరిగా DEBUG కింద లోడ్ చేసిన ఫైల్ ముగింపుకు మించి కనిపిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Knowing where legitimate information ends and where garbage begins is always important and not generally as clear-cut as it is here.","translation":"చట్టబద్ధమైన సమాచారం ఎక్కడ ముగుస్తుందో మరియు చెత్త ఎక్కడ ప్రారంభమవుతుందో తెలుసుకోవడం ఎల్లప్పుడూ ముఖ్యం మరియు సాధారణంగా ఇక్కడ ఉన్నంత స్పష్టంగా ఉండదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Changing Memory with DEBUG DEBUG can easily change bytes in memory, whether they are part of a file loaded from disk or not.","translation":"DEBUGతో మెమరీని మార్చడం DEBUG మెమరీలోని బైట్లను సులభంగా మార్చగలదు, అవి డిస్క్ నుండి లోడ్ చేయబడిన ఫైల్లో భాగమైనా లేదా కాకపోయినా.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Copy is useful when you have some standard text construction that you need to use several times within the same text file.","translation":"ఒకే టెక్స్ట్ ఫైల్లో మీరు చాలాసార్లు ఉపయోగించాల్సిన కొన్ని ప్రామాణిక టెక్స్ట్ నిర్మాణం ఉన్నప్పుడు కాపీ ఉపయోగపడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Rather than type it from the keyboard each time, you type it once, mark it as a block, and then copy it to the clipboard by pressing Ctrl-Ins.","translation":"ప్రతిసారీ కీబోర్డ్ నుండి టైప్ చేయడానికి బదులుగా, మీరు ఒకసారి టైప్ చేసి, దానిని బ్లాక్గా గుర్తించి, ఆపై Ctrl-Ins నొక్కడం ద్వారా క్లిప్బోర్డ్కు కాపీ చేయండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Ctrl-Ins will copy the highlighted block of text to the clipboard.","translation":"Ctrl-Ins హైలైట్ చేసిన టెక్స్ట్ బ్లాక్ను క్లిప్బోర్డ్కు కాపీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Once it's in the clipboard, you move the cursor position to where you need it.","translation":"ఇది క్లిప్బోర్డ్లో ఉన్న తర్వాత, మీరు కర్సర్ స్థానాన్ని మీకు ఎక్కడ అవసరమో అక్కడికి తరలించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Simply put the cursor where the first character of the copied text must go, and then issue the Paste command: Shift-Ins will paste the clipboard contents to the cursor position.","translation":"కాపీ చేసిన టెక్స్ట్ యొక్క మొదటి అక్షరం ఎక్కడ ఉండాలో అక్కడ కర్సర్ను ఉంచండి, ఆపై పేస్ట్ ఆదేశాన్ని ఇవ్వండి: Shift-Ins క్లిప్బోర్డ్ విషయాలను కర్సర్ స్థానానికి అతికించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Moving a block of text is similar to copying a block of text.","translation":"టెక్స్ట్ బ్లాక్ను తరలించడం టెక్స్ట్ బ్లాక్ను కాపీ చేయడానికి సమానంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The difference, of course, is that the marked block of text vanishes from its original position and reappears at the cursor position.","translation":"వాస్తవానికి, వ్యత్యాసం ఏమిటంటే, గుర్తించబడిన టెక్స్ట్ బ్లాక్ దాని అసలు స్థానం నుండి అదృశ్యమై కర్సర్ స్థానంలో తిరిగి కనిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It must pass through the clipboard on its way from one place to another.","translation":"ఇది ఒక స్థలం నుండి మరొక స్థానానికి వెళ్ళేటప్పుడు క్లిప్బోర్డ్ ద్వారా వెళ్ళాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"As with copying a block, the process of moving text requires two operations: First you cut the block from its original position into the clipboard, and then you paste the block from the clipboard to the cursor position.","translation":"ఒక బ్లాక్ను కాపీ చేసినట్లే, టెక్స్ట్ను తరలించే ప్రక్రియకు రెండు కార్యకలాపాలు అవసరం: మొదట మీరు బ్లాక్ను దాని అసలు స్థానం నుండి క్లిప్బోర్డ్లోకి కత్తిరించండి, ఆపై మీరు బ్లాక్ను క్లిప్బోర్డ్ నుండి కర్సర్ స్థానానికి అతికించండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Cutting the block is done by highlighting a block of text and then pressing Shift-Del: Shift-Del will cut the highlighted block of text to the clipboard.","translation":"టెక్స్ట్ బ్లాక్ను హైలైట్ చేసి, ఆపై Shift-Del నొక్కడం ద్వారా బ్లాక్ను కత్తిరించవచ్చు: Shift-Del హైలైట్ చేసిన టెక్స్ట్ బ్లాక్ను క్లిప్బోర్డ్కు కత్తిరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Once the block of text is in the clipboard, you can use the Shift-Ins hot key to paste the text from the clipboard to the cursor position, just as you did to copy a block to multiple places in the file or in different files.","translation":"టెక్స్ట్ బ్లాక్ క్లిప్బోర్డ్లో ఉన్న తర్వాత, మీరు ఫైల్లోని లేదా వేర్వేరు ఫైల్లలోని బహుళ స్థానాలకు ఒక బ్లాక్ను కాపీ చేసినట్లే, క్లిప్బోర్డ్ నుండి కర్సర్ స్థానానికి టెక్స్ట్ను అతికించడానికి Shift-Ins హాట్ కీని ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"All of the clipboard-related commands may also be given from the Edit menu.","translation":"క్లిప్బోర్డ్కు సంబంధించిన అన్ని ఆదేశాలను ఎడిట్ మెనూ నుండి కూడా ఇవ్వవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Once you mark a block by highlighting it, you can pull down the Edit menu and select the Cut, Copy, or Clear items to act on the marked block.","translation":"మీరు దానిని హైలైట్ చేయడం ద్వారా ఒక బ్లాక్ను గుర్తించిన తర్వాత, మీరు ఎడిట్ మెనూని తెరిచి, గుర్తించబడిన బ్లాక్పై చర్య తీసుకోవడానికి కట్, కాపీ లేదా క్లియర్ అంశాలను ఎంచుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Once you have some text in the clipboard, you can pull down the Edit menu and select Paste to paste the clipboard text into the current file at the cursor position.","translation":"మీరు క్లిప్బోర్డ్లో కొంత టెక్స్ట్ కలిగి ఉన్న తర్వాత, మీరు ఎడిట్ మెనూని తెరిచి, కర్సర్ స్థానంలో ప్రస్తుత ఫైల్లోకి క్లిప్బోర్డ్ టెక్స్ట్ను అతికించడానికి పేస్ట్ ఎంచుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One final clipboard command allows you to actually look at what text is currently in the clipboard.","translation":"చివరి క్లిప్బోర్డ్ ఆదేశం ప్రస్తుతం క్లిప్బోర్డ్లో ఏ టెక్స్ట్ ఉందో చూడటానికి మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This command is available only from the Edit menu.","translation":"ఈ ఆదేశం ఎడిట్ మెనూ నుండి మాత్రమే అందుబాటులో ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When you select Edit|Show clipboard, a text window will open that shows exactly what text is in the clipboard.","translation":"మీరు ఎడిట్|షో క్లిప్బోర్డ్ను ఎంచుకున్నప్పుడు, క్లిప్బోర్డ్లో ఏ టెక్స్ట్ ఉందో సరిగ్గా చూపే టెక్స్ట్ విండో తెరుచుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can edit the text if you like, and your changes will be reflected in the text that you paste into your other file or files.","translation":"మీరు కావాలనుకుంటే టెక్స్ట్ను సవరించవచ్చు మరియు మీరు ఇతర ఫైల్ లేదా ఫైల్లలో అతికించే టెక్స్ట్లో మీ మార్పులు ప్రతిబింబిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When you're finished looking at the clipboard text in its window, click on the close control (the small square on the left end of the top edge of the window) and it will close.","translation":"మీరు విండోలో క్లిప్బోర్డ్ టెక్స్ట్ను చూడటం పూర్తి చేసినప్పుడు, క్లోజ్ కంట్రోల్ (విండో యొక్క ఎగువ అంచు యొక్క ఎడమ చివరన ఉన్న చిన్న చతురస్రం)పై క్లిక్ చేయండి మరియు అది మూసివేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The clipboard text, however, remains on the clipboard.","translation":"అయితే, క్లిప్బోర్డ్ టెక్స్ట్ క్లిప్బోర్డ్లోనే ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Understanding the way segments work will help you understand how the two x86 flat models work.","translation":"సెగ్మెంట్లు ఎలా పని చేస్తాయో అర్థం చేసుకోవడం వల్ల రెండు x86 ఫ్లాట్ మోడల్స్ ఎలా పని చేస్తాయో అర్థం చేసుకోవడానికి మీకు సహాయపడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Programming involves two major components of the PC: the CPU and memory.","translation":"ప్రోగ్రామింగ్లో PC యొక్క రెండు ప్రధాన భాగాలు ఉన్నాయి: CPU మరియు మెమరీ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Most books begin by choosing one or the other and describing it.","translation":"చాలా పుస్తకాలు రెండింటిలో ఒకదాన్ని ఎంచుకుని దానిని వివరించడం ద్వారా ప్రారంభమవుతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"My own opinion is that you can't really describe memory and memory addressing without describing the CPU.","translation":"CPUని వివరించకుండా మెమరీ మరియు మెమరీ అడ్రసింగ్ను నిజంగా వివరించలేరని నా అభిప్రాయం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When running in segmented real mode, the x86 CPUs can use up to a megabyte of directly addressable memory.","translation":"సెగ్మెంటెడ్ రియల్ మోడ్లో రన్ అవుతున్నప్పుడు, x86 CPUలు నేరుగా అడ్రస్ చేయగల మెమరీ యొక్క మెగాబైట్ను ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Most modern x86 machines have a lot more memory than that—typically 32 MB or more.","translation":"చాలా ఆధునిక x86 మెషీన్లు దానికంటే చాలా ఎక్కువ మెమరీని కలిగి ఉంటాయి - సాధారణంగా 32 MB లేదా అంతకంటే ఎక్కువ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"However, most modern x86 machines run in protected mode, which can address up to 4 giga bytes of memory.","translation":"అయితే, చాలా ఆధునిక x86 మెషీన్లు ప్రొటెక్టెడ్ మోడ్లో రన్ అవుతాయి, ఇది 4 గిగాబైట్ల వరకు మెమరీని అడ్రస్ చేయగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"As I discussed briefly in Chapter 3, a megabyte of memory is actually not 1 million bytes of memory, but 1,048,576 bytes.","translation":"నేను అధ్యాయం 3లో క్లుప్తంగా చర్చించినట్లుగా, ఒక మెగాబైట్ మెమరీ వాస్తవానికి 1 మిలియన్ బైట్ల మెమరీ కాదు, కానీ 1,048,576 బైట్లు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The number 100000000000000000000B is so bulky that it's better to express it in the compatible (and much more compact) base 16, which we call hexadecimal.","translation":"100000000000000000000B సంఖ్య చాలా పెద్దదిగా ఉంది, దీనిని అనుకూలమైన (మరియు చాలా కాంపాక్ట్) బేస్ 16లో వ్యక్తీకరించడం మంచిది, దీనిని మనం హెక్సాడెసిమల్ అని పిలుస్తాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In a bank of memory containing 100000H bytes, what's the address of the very last byte in the memory bank?","translation":"100000H బైట్లను కలిగి ఉన్న మెమరీ బ్యాంకులో, మెమరీ బ్యాంకులోని చివరి బైట్ చిరునామా ఏమిటి?","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The address of a byte in a memory bank is just the number of that byte starting from zero.","translation":"మెమరీ బ్యాంకులోని బైట్ చిరునామా సున్నా నుండి ప్రారంభమయ్యే ఆ బైట్ సంఖ్య మాత్రమే.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The last in a row of four items is item number 3, because the first item in a row of four is item number 0.","translation":"నాలుగు అంశాల వరుసలో చివరిది 3వ అంశం, ఎందుకంటే నాలుగు అంశాల వరుసలో మొదటి అంశం 0వ అంశం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The addresses in a megabyte of memory, then, run from 00000H to 0FFFFFH.","translation":"అప్పుడు, ఒక మెగాబైట్ మెమరీలోని చిరునామాలు 00000H నుండి 0FFFFFH వరకు ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Modern x86 CPUs such as the Pentium can address much more memory than this and have a lot of machinery that I won't be discussing in this book.","translation":"Pentium వంటి ఆధునిక x86 CPUలు దీనికంటే చాలా ఎక్కువ మెమరీని అడ్రస్ చేయగలవు మరియు ఈ పుస్తకంలో నేను చర్చించని చాలా యంత్రాలను కలిగి ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When a Pentium CPU places itself into real mode segmented model, it very nearly becomes an 8086.","translation":"ఒక Pentium CPU తనను తాను రియల్ మోడ్ సెగ్మెంటెడ్ మోడల్లో ఉంచినప్పుడు, అది దాదాపు 8086 అవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Think of it as training wheels to get you up to speed in assembly language.","translation":"అసెంబ్లీ భాషలో వేగాన్ని పెంచడానికి ఇది శిక్షణ చక్రాలుగా భావించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When you launch an MS-DOS window or \"DOS box\" under Windows 9x or NT, you're creating what amounts to a little real mode island inside the Windows protected mode memory system.","translation":"మీరు Windows 9x లేదా NT కింద MS-DOS విండో లేదా \"DOS బాక్స్\"ని ప్రారంభించినప్పుడు, మీరు Windows ప్రొటెక్టెడ్ మోడ్ మెమరీ సిస్టమ్లో చిన్న రియల్ మోడ్ ద్వీపాన్ని సృష్టిస్తున్నారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In real mode segmented model, an x86 CPU can \"see\" a full megabyte of memory.","translation":"రియల్ మోడ్ సెగ్మెంటెడ్ మోడల్లో, x86 CPU ఒక పూర్తి మెగాబైట్ మెమరీని \"చూడగలదు\".","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU can slide that piece of cardboard up and down the full length of its memory system.","translation":"CPU ఆ కార్డ్బోర్డ్ ముక్కను దాని మెమరీ సిస్టమ్ యొక్క పూర్తి పొడవు వరకు పైకి క్రిందికి జారవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The key to understanding this admittedly metaphysical definition of a segment is knowing how segments are used.","translation":"ఒక సెగ్మెంట్ యొక్క ఈ మెటాఫిజికల్ నిర్వచనాన్ని అర్థం చేసుకోవడానికి కీలకం ఏమిటంటే సెగ్మెంట్లు ఎలా ఉపయోగించబడుతున్నాయో తెలుసుకోవడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The MOV instruction is the single most common activity in assembly language work.","translation":"అసెంబ్లీ భాషలో పని చేయడానికి MOV సూచన చాలా సాధారణమైనది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Immediate data is built right into the machine instruction.","translation":"తక్షణ డేటా నేరుగా మెషిన్ సూచనలో నిర్మించబడింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Register addressing is done by simply naming the register we want to work with.","translation":"రిజిస్టర్ చిరునామాను మనం పని చేయాలనుకుంటున్న రిజిస్టర్ను పేర్కొనడం ద్వారా చేస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The assembler keeps track of certain things that don't make sense.","translation":"అసెంబ్లర్ అర్థం లేని కొన్ని విషయాలను ట్రాక్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Memory data is stored somewhere in the megabyte vastness of real mode memory.","translation":"మెమరీ డేటా రియల్ మోడ్ మెమరీ యొక్క మెగాబైట్ విస్తారంలో ఎక్కడో నిల్వ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In the best of all worlds, every register could be used for all purposes.","translation":"అన్ని ప్రపంచాలలో ఉత్తమమైనది, ప్రతి రిజిస్టర్ను అన్ని ప్రయోజనాల కోసం ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each register has some ability that none of the others share.","translation":"ప్రతి రిజిస్టర్కు ఇతరులెవ్వరూ పంచుకోని కొన్ని సామర్థ్యాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You need to develop a grasp of them, or you'll be floundering around wondering why things don't work.","translation":"మీరు వాటిని అర్థం చేసుకోవాలి, లేకపోతే, ఎందుకు పని చేయవో అని మీరు ఆశ్చర్యపోతూ ఉంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"MOV can move a byte, word (16 bits), or double word (32 bits) of data.","translation":"MOV ఒక బైట్, పదం (16 బిట్స్) లేదా డబుల్ పదం (32 బిట్స్) డేటాను తరలించగలదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Once copied to the destination, however, the data does not vanish from the source.","translation":"అయితే, గమ్యస్థానానికి కాపీ చేసిన తర్వాత, డేటా మూలం నుండి అదృశ్యం కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Bring up DEBUG and use the R command to display the current state of the registers.","translation":"DEBUGని తీసుకురండి మరియు రిజిస్టర్ల ప్రస్తుత స్థితిని ప్రదర్శించడానికి R కమాండ్ ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The registers all get default values, most of which are zero.","translation":"రిజిస్టర్లన్నీ డిఫాల్ట్ విలువలను పొందుతాయి, వాటిలో చాలా వరకు సున్నా.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Machine instructions are just numbers, after all, and what numbers in memory do depends completely on how you interpret them.","translation":"మెషిన్ సూచనలు కేవలం సంఖ్యలు మాత్రమే, మరియు మెమరీలోని సంఖ్యలు మీరు వాటిని ఎలా అర్థం చేసుకుంటారనే దానిపై పూర్తిగా ఆధారపడి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each time you enter an instruction, IP is incremented to the next free location in memory.","translation":"మీరు ప్రతి సూచనను నమోదు చేసినప్పుడు, IP మెమరీలోని తదుపరి ఉచిత స్థానానికి పెరుగుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Go executes programs in memory starting at CS:IP; Trace executes the single instruction at CS:IP.","translation":"Go CS:IP వద్ద ప్రారంభమయ్యే మెమరీలో ప్రోగ్రామ్లను అమలు చేస్తుంది; Trace CS:IP వద్ద ఒకే సూచనను అమలు చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The Trace command will execute the machine instruction at CS:IP, then give control of the machine back to DEBUG.","translation":"Trace కమాండ్ CS:IP వద్ద మెషిన్ సూచనను అమలు చేస్తుంది, ఆపై మెషిన్ నియంత్రణను DEBUGకి తిరిగి ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The MOV instruction is an extremely versatile instruction.","translation":"MOV సూచన చాలా బహుముఖ సూచన.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"By convention in assembly language, the first operand belonging to a machine instruction is the destination operand.","translation":"అసెంబ్లీ భాషలో, ఒక మెషిన్ సూచనకు చెందిన మొదటి ఆపరేండ్ గమ్యస్థాన ఆపరేండ్.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The sense of source and destination is not nearly so literal in other instructions.","translation":"సోర్స్ మరియు డెస్టినేషన్ యొక్క భావం ఇతర సూచనలలో అంత స్పష్టంగా లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Immediate data must be of an appropriate size for the operand.","translation":"తక్షణ డేటా ఆపరేండ్ కోసం తగిన పరిమాణంలో ఉండాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The general-purpose registers are memory locations existing inside the CPU chip itself.","translation":"సాధారణ-ఉద్దేశ్య రిజిస్టర్లు CPU చిప్ లోపల ఉన్న మెమరీ స్థానాలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Also, like the segment registers, they all have names rather than numeric addresses.","translation":"సెగ్మెంట్ రిజిస్టర్ల వలె, వాటికి సంఖ్యా చిరునామాలకు బదులుగా పేర్లు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"However, some of the general-purpose registers also have what I call a hidden agenda.","translation":"అయితే, కొన్ని సాధారణ-ఉద్దేశ్య రిజిస్టర్లకు నేను రహస్య ఎజెండా అని పిలిచేది కూడా ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"I explain all these hidden agendas as I go—keeping in mind that some of the hidden agendas are actually limitations of the older 16-bit machines.","translation":"నేను వెళ్లేటప్పుడు ఈ దాచిన ఎజెండాలన్నింటినీ వివరిస్తాను—కొన్ని దాచిన ఎజెండాలు వాస్తవానికి పాత 16-బిట్ యంత్రాల పరిమితులు అని గుర్తుంచుకోండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The newer general-purpose registers are much more..., er,...general.","translation":"కొత్త సాధారణ-ఉద్దేశ్య రిజిస్టర్లు చాలా ఎక్కువ..., ఎర్,...సాధారణమైనవి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The 16- bit and 8-bit registers are actually names of regions inside the 32-bit registers.","translation":"16-బిట్ మరియు 8-బిట్ రిజిస్టర్లు వాస్తవానికి 32-బిట్ రిజిస్టర్లలోని ప్రాంతాల పేర్లు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Adding a room to your house doesn't make it two houses—just one bigger house.","translation":"మీ ఇంటికి ఒక గదిని జోడించడం వలన అది రెండు ఇళ్ళు అవ్వదు—ఒక పెద్ద ఇల్లు మాత్రమే.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"There are eight 16-bit general-purpose registers: AX, BX, CX, DX, BP, SI, DI, and SP.","translation":"ఎనిమిది 16-బిట్ సాధారణ-ఉద్దేశ్య రిజిస్టర్లు ఉన్నాయి: AX, BX, CX, DX, BP, SI, DI, మరియు SP.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When Intel expanded the x86 architecture to 32 bits in 1986, it doubled the size of all eight registers and gave them new names.","translation":"ఇంటెల్ 1986లో x86 ఆర్కిటెక్చర్ను 32 బిట్లకు విస్తరించినప్పుడు, అది ఎనిమిది రిజిస్టర్ల పరిమాణాన్ని రెట్టింపు చేసింది మరియు వాటికి కొత్త పేర్లు ఇచ్చింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"So...were these just bigger registers, or new registers? Both.","translation":"కాబట్టి... ఇవి పెద్ద రిజిస్టర్లా, లేక కొత్త రిజిస్టర్లా? రెండూ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Each of the four registers shown in Figure 6.6 is fully 32 bits in size.","translation":"చిత్రం 6.6లో చూపబడిన నాలుగు రిజిస్టర్లలో ప్రతి ఒక్కటి పూర్తిగా 32 బిట్ల పరిమాణంలో ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If you're writing programs for an 8088 machine such as the ancient IBM PC, you can only reference the DI part.","translation":"మీరు పురాతన IBM PC వంటి 8088 యంత్రం కోసం ప్రోగ్రామ్లు రాస్తుంటే, మీరు DI భాగాన్ని మాత్రమే సూచించగలరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Unfortunately, the high 16 bits of the 32-bit general-purpose registers do not have their own names.","translation":"దురదృష్టవశాత్తు, 32-బిట్ సాధారణ-ఉద్దేశ్య రిజిస్టర్ల యొక్క అధిక 16 బిట్లకు వాటి స్వంత పేర్లు లేవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The same is true for the other four general-purpose registers EAX, EBX, ECX, and EDX, but there's an additional twist.","translation":"ఇతర నాలుగు సాధారణ-ఉద్దేశ్య రిజిస్టర్లు EAX, EBX, ECX, మరియు EDX విషయంలో కూడా ఇదే నిజం, కానీ అదనపు ట్విస్ట్ ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The 16-bit registers AX, BX, CX, and DX are present as the lower 16-bit portions of EAX, EBX, ECX, and EDX.","translation":"16-బిట్ రిజిస్టర్లు AX, BX, CX, మరియు DX, EAX, EBX, ECX, మరియు EDX యొక్క దిగువ 16-బిట్ భాగాల వలె ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"One nice thing about the 8-bit register halves is that you can read and change one half of a 16-bit number without disturbing the other half.","translation":"8-బిట్ రిజిస్టర్ సగానికి సంబంధించిన ఒక మంచి విషయం ఏమిటంటే, మీరు మరొక సగాన్ని కలవరపరచకుండా 16-బిట్ సంఖ్యలో ఒక సగాన్ని చదవవచ్చు మరియు మార్చవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each register half can be considered a separate register, leaving you twice the number of places to put things while your program works.","translation":"ప్రతి రిజిస్టర్ సగాన్ని ఒక ప్రత్యేక రిజిస్టర్గా పరిగణించవచ్చు, ఇది మీ ప్రోగ్రామ్ పని చేస్తున్నప్పుడు విషయాలను ఉంచడానికి మీకు రెట్టింపు స్థలాలను వదిలివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Keep in mind that this dual nature involves only the 16-bit general-purpose registers AX, BX, CX, and DX.","translation":"ఈ ద్వంద్వ స్వభావం కేవలం 16-బిట్ సాధారణ-ఉద్దేశ్య రిజిస్టర్లు AX, BX, CX, మరియు DX లను మాత్రమే కలిగి ఉంటుందని గుర్తుంచుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The instruction pointer (usually called IP) is in a class by itself.","translation":"ఇన్స్ట్రక్షన్ పాయింటర్ (సాధారణంగా IP అని పిలుస్తారు) దాని స్వంత తరగతిలో ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In radical contrast to the gang of eight general-purpose registers, IP is a specialist par excellence—more of a specialist than even the segment registers.","translation":"ఎనిమిది సాధారణ-ఉద్దేశ్య రిజిస్టర్ల సమూహానికి పూర్తి విరుద్ధంగా, IP ఒక నిపుణుడు—సెగ్మెంట్ రిజిస్టర్ల కంటే ఎక్కువ నిపుణుడు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In other words, you can move an immediate value to memory.","translation":"మాటల్లో చెప్పాలంటే, మీరు తక్షణ విలువను మెమరీకి తరలించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is just an inherent limitation of the CPU.","translation":"ఇది కేవలం CPU యొక్క సహజమైన పరిమితి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Specifying a memory address as one of an instruction's operands is a little complicated.","translation":"ఒక సూచన యొక్క ఆపరేండ్లలో ఒకటిగా మెమరీ చిరునామాను పేర్కొనడం కొంచెం సంక్లిష్టంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The offset address must be resident in one of the general-purpose registers.","translation":"ఆఫ్సెట్ చిరునామా సాధారణ-ప్రయోజన రిజిస్టర్లలో ఒకదానిలో ఉండాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"To specify that we want the data at the memory location contained in the register, we use square brackets around the name of the register.","translation":"రిజిస్టర్లో ఉన్న మెమరీ స్థానంలో డేటాను మేము కోరుకుంటున్నాము అని పేర్కొనడానికి, మేము రిజిస్టర్ పేరు చుట్టూ చతురస్రాకార బ్రాకెట్లను ఉపయోగిస్తాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Similarly, to move a value residing in register DX into the word at address DS:DI, you would use this instruction: MOV [DI],DX","translation":"అదేవిధంగా, DX రిజిస్టర్లో ఉన్న విలువను DS:DI చిరునామా వద్ద ఉన్న పదానికి తరలించడానికి, మీరు ఈ సూచనను ఉపయోగిస్తారు: MOV [DI],DX","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The only problem with these examples is this: \"DS\" isn't anywhere in either instruction.","translation":"ఈ ఉదాహరణలతో ఉన్న ఏకైక సమస్య ఏమిటంటే: \"DS\" ఏ సూచనలోనూ లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"To keep addressing notation simple, the x86 CPUs in real mode make certain assumptions about certain instructions.","translation":"చిరునామా సంజ్ఞామానాన్ని సరళంగా ఉంచడానికి, నిజమైన మోడ్లోని x86 CPUలు కొన్ని సూచనల గురించి కొన్ని ఊహలను చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One of these assumptions is that in working with memory data, the MOV instruction uses the segment address stored in segment register DS.","translation":"ఈ ఊహలలో ఒకటి ఏమిటంటే మెమరీ డేటాతో పని చేస్తున్నప్పుడు, MOV సూచన సెగ్మెంట్ రిజిస్టర్ DS లో నిల్వ చేయబడిన సెగ్మెంట్ చిరునామాను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"However, had you specified the offset as residing in register SP instead of BX or DI, the MOV instruction would have assumed the use of segment register SS instead.","translation":"అయితే, మీరు ఆఫ్సెట్ను BX లేదా DIకి బదులుగా రిజిస్టర్ SPలో ఉన్నట్లు పేర్కొన్నట్లయితే, MOV సూచన సెగ్మెంట్ రిజిస్టర్ SSని ఉపయోగించినట్లు ఊహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It's not difficult.","translation":"ఇది కష్టం కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The instruction set includes what are called segment override prefixes.","translation":"సూచన సెట్లో సెగ్మెంట్ ఓవర్రైడ్ పూర్వపదాలు అని పిలువబడేవి ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"These are not precisely instructions, but are more like the filters that may be snapped in front of a camera lens.","translation":"ఇవి ఖచ్చితంగా సూచనలు కావు, కానీ కెమెరా లెన్స్ ముందు ఉంచబడే ఫిల్టర్ల వంటివి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"For example, to force a MOV instruction to copy a value from the AX register into a location at some offset (contained in SI) into the code segment, you would use this instruction: MOV [CS:SI],AX","translation":"ఉదాహరణకు, AX రిజిస్టర్ నుండి కోడ్ సెగ్మెంట్లోని కొంత ఆఫ్సెట్ (SIలో ఉంది) వద్ద ఉన్న స్థానానికి విలువను కాపీ చేయడానికి MOV సూచనను బలవంతం చేయడానికి, మీరు ఈ సూచనను ఉపయోగిస్తారు: MOV [CS:SI],AX","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Every reference to memory data includes either an assumed segment register or else a segment override prefix to specify a segment register other than the assumed segment register.","translation":"మెమరీ డేటాకు సంబంధించిన ప్రతి సూచనలో ఊహించిన సెగ్మెంట్ రిజిస్టర్ లేదా ఊహించిన సెగ్మెంట్ రిజిస్టర్కు బదులుగా మరొక సెగ్మెంట్ రిజిస్టర్ను పేర్కొనడానికి సెగ్మెంట్ ఓవర్రైడ్ పూర్వపదం ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"At the machine-code level, a segment override prefix is a single binary byte.","translation":"మెషిన్-కోడ్ స్థాయిలో, సెగ్మెంట్ ఓవర్రైడ్ పూర్వపదం ఒకే బైనరీ బైట్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In the flat models you do not use segment overrides.","translation":"ఫ్లాట్ మోడల్లలో మీరు సెగ్మెంట్ ఓవర్రైడ్లను ఉపయోగించరు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Real mode memory data consists of a single byte or word in memory, addressed by way of a segment value and an offset value.","translation":"నిజమైన మోడ్ మెమరీ డేటాలో మెమరీలో ఒకే బైట్ లేదా పదం ఉంటుంది, ఇది సెగ్మెంట్ విలువ మరియు ఆఫ్సెట్ విలువ ద్వారా పరిష్కరించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The register containing the offset address is enclosed in square brackets to indicate that the contents of memory, rather than the contents of the register, are being addressed.","translation":"ఆఫ్సెట్ చిరునామాను కలిగి ఉన్న రిజిస్టర్ చతురస్రాకార బ్రాకెట్లలో ఉంచబడుతుంది, ఇది రిజిస్టర్ యొక్క విషయాలకు బదులుగా మెమరీలోని విషయాలను పరిష్కరించబడుతుందని సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The segment address may reside in any of the four segment registers: CS, DS, SS, or ES.","translation":"సెగ్మెంట్ చిరునామా నాలుగు సెగ్మెంట్ రిజిస్టర్లలో దేనిలోనైనా ఉండవచ్చు: CS, DS, SS లేదా ES.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A general-purpose (GP) register by itself can specify any memory location in the full memory address space.","translation":"ఒక సాధారణ-ఉద్దేశ్య (GP) రిజిస్టర్ దాని స్వంతంగా పూర్తి మెమరీ చిరునామా స్థలంలో ఏదైనా మెమరీ స్థానాన్ని పేర్కొనగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Memory addressing and registers are key in this business.","translation":"మెమరీ చిరునామా మరియు రిజిస్టర్లు ఈ వ్యాపారంలో కీలకం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If you know them, the instructions will be a snap.","translation":"మీకు తెలిస్తే, సూచనలు సులభంగా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"What difficulty exists in programming for protected mode flat model lies in understanding the operating system, its requirements, and its restrictions.","translation":"రక్షిత మోడ్ ఫ్లాట్ మోడల్ కోసం ప్రోగ్రామింగ్లో ఉన్న కష్టం ఏమిటంటే, ఆపరేటింగ్ సిస్టమ్, దాని అవసరాలు మరియు దాని పరిమితులను అర్థం చేసుకోవడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This book is only the beginning-there's a long road out there to be walked, and you're barely off the curb.","translation":"ఈ పుస్తకం ప్రారంభం మాత్రమే - అక్కడ నడవడానికి చాలా దూరం ఉంది, మరియు మీరు అంచు నుండి బయటకు రాలేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Machine instructions act on registers, and registers define how memory is addressed and what is read from or placed there.","translation":"మెషిన్ సూచనలు రిజిస్టర్లపై పనిచేస్తాయి మరియు రిజిస్టర్లు మెమరీని ఎలా అడ్రస్ చేయాలో మరియు అక్కడ ఏమి చదవాలి లేదా ఉంచాలి అని నిర్వచిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The DOS DEBUG utility provides a handy window into the CPU's hidden world of registers.","translation":"DOS DEBUG యుటిలిటీ CPU యొక్క రిజిస్టర్ల రహస్య ప్రపంచంలోకి ఒక సులభమైన విండోను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Simply run DEBUG, and at the dash prompt type the single-letter command R.","translation":"DEBUGని రన్ చేయండి మరియు డాష్ ప్రాంప్ట్ వద్ద R అనే ఒక అక్షర కమాండ్ టైప్ చేయండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The display will look something very close to this: - R AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000 DS=1980 ES=1980 SS=1980 CS=1980 IP=0100 NV UP EI PL NZ NA PO NC 1980:0100 389A5409 CMP [BP+SI+0954],BL SS:0954=8A","translation":"ప్రదర్శన దీనికి చాలా దగ్గరగా ఉంటుంది: - R AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000 DS=1980 ES=1980 SS=1980 CS=1980 IP=0100 NV UP EI PL NZ NA PO NC 1980:0100 389A5409 CMP [BP+SI+0954],BL SS:0954=8A","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"What will not vary is the fact that every CPU register has its place in the display, along with its current value shown to the right of an equals sign.","translation":"ప్రతి CPU రిజిస్టర్ ప్రదర్శనలో దాని స్థానాన్ని కలిగి ఉందనే వాస్తవం మారదు, సమాన గుర్తు కుడి వైపున చూపబడిన దాని ప్రస్తుత విలువతో పాటు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Changing a register is done very simply, again using DEBUG's R command.","translation":"ఒక రిజిస్టర్ను మార్చడం చాలా సులభంగా చేయబడుతుంది, మళ్ళీ DEBUG యొక్క R కమాండ్ ఉపయోగించి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"To change the value of AX, type R AX and press Enter:","translation":"AX విలువను మార్చడానికి, R AX అని టైప్ చేసి ఎంటర్ నొక్కండి:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"DEBUG will respond by displaying the current value of AX (here, \"0000\") and then, on the following line, a colon prompt.","translation":"DEBUG AX యొక్క ప్రస్తుత విలువను ప్రదర్శించడం ద్వారా స్పందిస్తుంది (ఇక్కడ, \"0000\") ఆపై, కింది లైన్లో, ఒక కోలన్ ప్రాంప్ట్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Take a few minutes to practice entering new values for the general-purpose registers, then display the registers as a group to verify that the changes were made.","translation":"సాధారణ-ఉద్దేశ్య రిజిస్టర్ల కోసం కొత్త విలువలను నమోదు చేయడానికి కొన్ని నిమిషాలు ప్రాక్టీస్ చేయండి, ఆపై మార్పులు జరిగాయో లేదో ధృవీకరించడానికి రిజిస్టర్లను సమూహంగా ప్రదర్శించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One good way to help your knowledge of memory addressing sink in is to use DEBUG to take a look at some interesting places in the PC's memory space.","translation":"మెమరీ చిరునామా గురించి మీ జ్ఞానాన్ని లోతుగా పెంచడానికి ఒక మంచి మార్గం ఏమిటంటే, PC యొక్క మెమరీ స్థలంలో కొన్ని ఆసక్తికరమైన స్థలాలను చూడటానికి DEBUGని ఉపయోగించడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A video refresh buffer is a region of memory with a difference: Any characters written to buffer memory are instantly displayed on the computer's screen.","translation":"వీడియో రిఫ్రెష్ బఫర్ అనేది ఒక వ్యత్యాసం ఉన్న మెమరీ ప్రాంతం: బఫర్ మెమరీకి వ్రాసిన ఏదైనా అక్షరాలు వెంటనే కంప్యూటర్ స్క్రీన్పై ప్రదర్శించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The text mode display buffer is the screen that appears when you're running DOS or else working in a DOS window (or \"DOS box\") from within MS Windows.","translation":"టెక్స్ట్ మోడ్ డిస్ప్లే బఫర్ అనేది మీరు DOSని రన్ చేస్తున్నప్పుడు లేదా MS విండోస్ లోపల నుండి DOS విండో (లేదా \"DOS బాక్స్\")లో పని చేస్తున్నప్పుడు కనిపించే స్క్రీన్.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If your PC has a color screen, the segment address of the video refresh buffer is 0B800H.","translation":"మీ PCకి కలర్ స్క్రీన్ ఉంటే, వీడియో రిఫ్రెష్ బఫర్ యొక్క సెగ్మెంట్ చిరునామా 0B800H.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The first 160 characters (80 ASCII codes plus their 80 attribute bytes) are shown as the first line, and the subsequent 160 characters are shown on the next line down the screen.","translation":"మొదటి 160 అక్షరాలు (80 ASCII కోడ్లు మరియు వాటి 80 లక్షణాల బైట్లు) మొదటి లైన్గా చూపబడతాయి మరియు తదుపరి 160 అక్షరాలు స్క్రీన్ దిగువన ఉన్న తదుపరి లైన్లో చూపబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The BIOS (Basic Input/Output System) is a collection of assembly language routines that perform basic services for the PC: disk handling, video handling, printer handling, and so forth.","translation":"BIOS (బేసిక్ ఇన్పుట్/అవుట్పుట్ సిస్టమ్) అనేది PC కోసం ప్రాథమిక సేవలను నిర్వహించే అసెంబ్లీ భాషా రొటీన్ల సమాహారం: డిస్క్ నిర్వహణ, వీడియో నిర్వహణ, ప్రింటర్ నిర్వహణ మొదలైనవి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The program EAT. ASM displays one (short) line of text on your display screen: Eat at Joe's!","translation":"EAT అనే ప్రోగ్రామ్. ASM మీ ప్రదర్శన తెరపై ఒక (చిన్న) టెక్స్ట్ లైన్ను ప్రదర్శిస్తుంది: జోస్ వద్ద తినండి!","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"With no other computer language is there anything even close to the risk of writing code that looks so much like something scraped off the wall of King Tut's tomb.","translation":"మరే ఇతర కంప్యూటర్ భాషలోనూ కోడ్ రాయడానికి దగ్గరగా ఏమీ లేదు, ఇది కింగ్ టుట్ సమాధి గోడ నుండి తీసినట్లుగా కనిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program EAT. ASM displays one (short) line of text on your display screen: Eat at Joe's!","translation":"EAT.ASM అనే ప్రోగ్రామ్ మీ తెరపై ఒక (చిన్న) టెక్స్ట్ లైన్ను ప్రదర్శిస్తుంది: జోస్ వద్ద తినండి!","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"For that you have to feed 28 lines of text file to the assembler.","translation":"దాని కోసం మీరు అసెంబ్లర్కు 28 లైన్ల టెక్స్ట్ ఫైల్ను అందించాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"One of the aims of assembly language coding is to use as few instructions as possible in getting the job done.","translation":"అసెంబ్లీ భాషా కోడింగ్ యొక్క లక్ష్యాలలో ఒకటి ఏమిటంటే, పనిని పూర్తి చేయడానికి వీలైనన్ని తక్కువ సూచనలను ఉపయోగించడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The more comments you put in your file, the better you'll remember how things work inside the program the next time you pick it up.","translation":"మీరు మీ ఫైల్లో ఎన్ని వ్యాఖ్యలు ఉంచితే, మీరు ప్రోగ్రామ్లో విషయాలు ఎలా పనిచేస్తాయో మరుసటిసారి మీరు దాన్ని తీసుకున్నప్పుడు అంత బాగా గుర్తుంచుకుంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"I think you'll find it amazing how quickly the logic of a complicated assembly language file goes cold in your head.","translation":"ఒక సంక్లిష్టమైన అసెంబ్లీ భాషా ఫైల్ యొక్క తర్కం మీ తలలో ఎంత త్వరగా చల్లబడుతుందో మీరు ఆశ్చర్యపోతారని నేను భావిస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"After no more than 48 hours of working on other projects, I've come back to assembler projects and had to struggle to get back to flank speed on development.","translation":"ఇతర ప్రాజెక్ట్లపై 48 గంటలకు మించి పని చేసిన తర్వాత, నేను అసెంబ్లర్ ప్రాజెక్ట్లకు తిరిగి వచ్చాను మరియు అభివృద్ధిపై ఫ్లాంక్ వేగానికి తిరిగి రావడానికి కష్టపడవలసి వచ్చింది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Comments are neither time nor space wasted.","translation":"వ్యాఖ్యలు సమయం లేదా స్థలం వృధా కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"IBM used to say, One line of comments per line of code.","translation":"IBM ఒకప్పుడు ఇలా చెప్పేది, కోడ్కు ఒక లైన్ వ్యాఖ్యలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A better course (that I will in fact follow in the more complicated examples later on) is to use one short line of commentary to the right of each line of code, along with a comment block at the start of each sequence of instructions that work together in accomplishing some discrete task.","translation":"ఒక మంచి మార్గం (వాస్తవానికి నేను తరువాత మరింత సంక్లిష్టమైన ఉదాహరణలలో అనుసరిస్తాను) ఏమిటంటే, ప్రతి కోడ్ లైన్ కుడి వైపున ఒక చిన్న వ్యాఖ్యాన పంక్తిని ఉపయోగించడం, అలాగే కొన్ని ప్రత్యేక పనిని సాధించడంలో కలిసి పనిచేసే సూచనల ప్రతి క్రమం ప్రారంభంలో ఒక వ్యాఖ్య బ్లాక్ను ఉపయోగించడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Here's the program. Read it carefully:","translation":"ఇదిగో ప్రోగ్రామ్. జాగ్రత్తగా చదవండి:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The first thing you'll notice is that there are no references to segments or segment registers anywhere.","translation":"మీరు గమనించే మొదటి విషయం ఏమిటంటే, సెగ్మెంట్లు లేదా సెగ్మెంట్ రిజిస్టర్లకు ఎక్కడా సూచనలు లేవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The reason for this is that in real mode flat model, you are inside a single segment, and everything you do, you do within that single segment.","translation":"దీనికి కారణం ఏమిటంటే, రియల్ మోడ్ ఫ్లాట్ మోడల్లో, మీరు ఒకే సెగ్మెంట్ లోపల ఉన్నారు మరియు మీరు చేసే ప్రతిదీ, మీరు ఆ ఒక్క సెగ్మెంట్ లోపల చేస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If everything happens within one single segment, the segments (in a sense) \"factor out\" and you can imagine that they don't exist.","translation":"అన్నీ ఒకే సెగ్మెంట్లో జరిగితే, సెగ్మెంట్లు (ఒక విధంగా) \"కారకం అవుతాయి\" మరియు అవి లేవని మీరు can హించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Once we assemble EAT. ASM and create a runnable program from it, I'll show you what those segment registers are up to and how it is that you can almost ignore them in real mode flat model.","translation":"ఒకసారి మేము EATని సమీకరించిన తర్వాత. ASM మరియు దాని నుండి అమలు చేయగల ప్రోగ్రామ్ను సృష్టించండి, ఆ సెగ్మెంట్ రిజిస్టర్లు ఏమి చేస్తున్నాయో మరియు రియల్ మోడ్ ఫ్లాట్ మోడల్లో మీరు వాటిని ఎలా దాదాపు విస్మరించవచ్చో నేను మీకు చూపిస్తాను.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"At the top is a summary comment block.","translation":"అగ్రభాగాన సారాంశ వ్యాఖ్య బ్లాక్ ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This text is for your use only.","translation":"ఈ టెక్స్ట్ మీ ఉపయోగం కోసం మాత్రమే.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When NASM processes a . ASM file, it strips out and discards all text between any semicolon and the end of the line the semicolon is in.","translation":"NASM .ASM ఫైల్ను ప్రాసెస్ చేసినప్పుడు, అది ఏదైనా సెమీకోలన్ మరియు సెమీకోలన్ ఉన్న లైన్ చివరి మధ్య ఉన్న మొత్తం టెక్స్ట్ ను తొలగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"I recommend placing a summary comment block like this at the top of every source code file you create.","translation":"మీరు సృష్టించే ప్రతి సోర్స్ కోడ్ ఫైల్ పైభాగంలో ఇలాంటి సారాంశ వ్యాఖ్య బ్లాక్ను ఉంచాలని నేను సిఫార్సు చేస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM16 is the name of the version of NASM intended for use with real mode programs under DOS.","translation":"NASM16 అనేది DOS కింద నిజమైన మోడ్ ప్రోగ్రామ్లతో ఉపయోగించడానికి ఉద్దేశించిన NASM యొక్క వెర్షన్ పేరు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"EAT. ASM is the name of the source code file you wish to assemble.","translation":"మీరు అసెంబుల్ చేయాలనుకుంటున్న సోర్స్ కోడ్ ఫైల్ పేరు EAT. ASM.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The one we want is the . COM file, which is generated as a simple binary image of the generated machine-code bytes and any initialized data.","translation":"మనకు కావలసినది .COM ఫైల్, ఇది ఉత్పత్తి చేయబడిన మెషిన్-కోడ్ బైట్లు మరియు ఏదైనా ప్రారంభించబడిన డేటా యొక్క సాధారణ బైనరీ చిత్రంగా ఉత్పత్తి చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The real mode flat model is simplicity itself—so simple, in fact, that it doesn't teach you much about segments.","translation":"నిజమైన మోడ్ ఫ్లాట్ మోడల్ సరళత—నిజానికి చాలా సులభం, ఇది మీకు విభాగాల గురించి పెద్దగా నేర్పించదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Let's do the Land Shark HyperBike trick again, this time with a version of EAT. ASM specifically written to use the real mode segmented model.","translation":"రండి, ల్యాండ్ షార్క్ హైపర్ బైక్ ట్రిక్ ని మళ్ళీ చేద్దాం, ఈసారి నిజమైన మోడ్ సెగ్మెంటెడ్ మోడల్ని ఉపయోగించడానికి ప్రత్యేకంగా వ్రాయబడిన EAT. ASM వెర్షన్తో.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Assembly language programs written for real mode segmented model must contain at least three segments: One for code, one for data, and one for the stack.","translation":"నిజమైన మోడ్ సెగ్మెంటెడ్ మోడల్ కోసం వ్రాసిన అసెంబ్లీ భాషా ప్రోగ్రామ్లు కనీసం మూడు విభాగాలను కలిగి ఉండాలి: కోడ్ కోసం ఒకటి, డేటా కోసం ఒకటి మరియు స్టాక్ కోసం ఒకటి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each segment has a name: stack,data, and code, which indicate pretty clearly what the segment is for.","translation":"ప్రతి విభాగంలో పేరు ఉంది: స్టాక్, డేటా మరియు కోడ్, ఇది విభాగం దేని కోసం ఉద్దేశించబడిందో స్పష్టంగా సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The segment containing the stack has some special considerations attached to it, especially regarding the linking of several files together into one executable program.","translation":"స్టాక్ను కలిగి ఉన్న విభాగంలో కొన్ని ప్రత్యేకమైన పరిశీలనలు ఉన్నాయి, ముఖ్యంగా అనేక ఫైల్లను ఒకే ఎగ్జిక్యూటబుల్ ప్రోగ్రామ్గా లింక్ చేయడం గురించి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In the real mode segmented mode, the different segments are indeed different and distinct regions of memory and are not all the same place.","translation":"నిజమైన మోడ్ సెగ్మెంటెడ్ మోడ్లో, విభిన్న విభాగాలు నిజంగా భిన్నమైనవి మరియు మెమరీ యొక్క ప్రత్యేక ప్రాంతాలు మరియు అవన్నీ ఒకే ప్రదేశంలో లేవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the program begins running, DOS doesn't set the segment registers to anything.","translation":"ప్రోగ్రామ్ అమలు చేయడం ప్రారంభించినప్పుడు, DOS సెగ్మెంట్ రిజిస్టర్లను ఏమీ సెట్ చేయదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This is what the first part of EATSEG. ASM does: It takes the addresses represented by the segment names for the data and stack segments and loads them into DS and SS, the segment registers governing those segments:","translation":"EATSEG. ASM యొక్క మొదటి భాగం చేసేది ఇదే: ఇది డేటా మరియు స్టాక్ విభాగాల కోసం సెగ్మెంట్ పేర్ల ద్వారా సూచించబడే చిరునామాలను తీసుకుంటుంది మరియు వాటిని DS మరియు SS లోకి లోడ్ చేస్తుంది, ఆ విభాగాలను నియంత్రించే సెగ్మెంట్ రిజిస్టర్లు:","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Keep in mind that you can only load a segment register from a general-purpose register- you can't load it from anything else, either immediate data or memory data.","translation":"మీరు ఒక సాధారణ-ప్రయోజన రిజిస్టర్ నుండి మాత్రమే సెగ్మెంట్ రిజిస్టర్ను లోడ్ చేయగలరని గుర్తుంచుకోండి - మీరు తక్షణ డేటా లేదా మెమరీ డేటా నుండి కూడా లోడ్ చేయలేరు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In MASM, Microsoft defines the ASSUME directive, which associates segment names with segment registers.","translation":"MASM లో, Microsoft ASSUME ఆదేశాన్ని నిర్వచిస్తుంది, ఇది సెగ్మెంట్ పేర్లను సెగ్మెంట్ రిజిస్టర్లతో అనుసంధానిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When you move away from the default addressing of memory variables relative to DS, you must include the segment register prefix inside the square brackets of all memory variable references!","translation":"మీరు DSకి సంబంధించిన మెమరీ వేరియబుల్స్ యొక్క డిఫాల్ట్ అడ్రసింగ్ నుండి దూరంగా వెళ్ళినప్పుడు, మీరు అన్ని మెమరీ వేరియబుల్ రిఫరెన్స్ల యొక్క స్క్వేర్ బ్రాకెట్లలో సెగ్మెంట్ రిజిస్టర్ ఉపసర్గను చేర్చాలి!","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This is not for NASM's benefit-it will not take any action of its own based on knowing that the segment named MyStack is in fact the stack segment.","translation":"ఇది NASM ప్రయోజనం కోసం కాదు- MyStack అనే విభాగం వాస్తవానికి స్టాక్ విభాగం అని తెలుసుకోవడం ఆధారంగా ఇది తన స్వంతంగా ఎటువంటి చర్య తీసుకోదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"DOS needs to know at what address to begin execution when it loads and runs the program.","translation":"ప్రోగ్రామ్ను లోడ్ చేసి, రన్ చేసినప్పుడు ఎగ్జిక్యూషన్ ఎక్కడ ప్రారంభించాలో DOS తెలుసుకోవాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Assembling EATSEG. ASM is done with the following command line: C:\\>NASM16 EATSEG. ASM -f obj -o EATSEG. OBJ","translation":"EATSEG. ASMని అసెంబ్లింగ్ చేయడం ఈ కమాండ్ లైన్తో చేయబడుతుంది: C:\\>NASM16 EATSEG. ASM -f obj -o EATSEG. OBJ","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Linking is even easier: C:\\>ALINK EATSEG. OBJ","translation":"లింకింగ్ మరింత సులభం: C:\\>ALINK EATSEG. OBJ","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"One problem with assembly language is that it's tough knowing where to put things.","translation":"అసెంబ్లీ భాషతో ఉన్న ఒక సమస్య ఏమిటంటే, వస్తువులను ఎక్కడ ఉంచాలో తెలుసుకోవడం కష్టం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The x86 stack is like that. We call it a last in, first out, or LIFO stack.","translation":"x86 స్టాక్ అలానే ఉంటుంది. మేము దానిని లాస్ట్ ఇన్, ఫస్ట్ అవుట్, లేదా LIFO స్టాక్ అని పిలుస్తాము.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In real mode flat model, SS is set to the base of the stack segment by DOS when the program is loaded.","translation":"నిజమైన మోడ్ ఫ్లాట్ మోడల్లో, ప్రోగ్రామ్ లోడ్ అయినప్పుడు DOS ద్వారా SS స్టాక్ విభాగం యొక్క ఆధారం వద్ద సెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can use RESB to reserve as much stack as you think you'll need; 64 bytes is enough for simple experimentation.","translation":"మీకు ఎంత స్టాక్ అవసరమో రిజర్వ్ చేయడానికి మీరు RESBని ఉపయోగించవచ్చు; సాధారణ ప్రయోగానికి 64 బైట్లు సరిపోతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"SP is set to the far (that is, the high, address-wise) end of the stack segment.","translation":"SP స్టాక్ విభాగం యొక్క దూరం (అంటే, అధిక, చిరునామా-జ్ఞానంతో) ముగింపుకు సెట్ చేయబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Pushing Data You can place data onto the stack in numerous ways.","translation":"డేటాను నెట్టడం మీరు అనేక మార్గాల్లో స్టాక్పై డేటాను ఉంచవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"PUSHF pushes the Flags register onto the stack.","translation":"PUSHF ఫ్లాగ్ల రిజిస్టర్ను స్టాక్పైకి నెట్టివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"PUSH pushes a 16-bit register or memory value that is specified by you in your source code.","translation":"PUSH అనేది మీ సోర్స్ కోడ్లో మీరు పేర్కొన్న 16-బిట్ రిజిస్టర్ లేదా మెమరీ విలువను నెట్టివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"First SP is decremented by one word (two bytes) so that it points to an empty area of the stack segment that is two bytes long.","translation":"ముందుగా SP ఒక పదం (రెండు బైట్లు) ద్వారా తగ్గించబడుతుంది, తద్వారా అది రెండు బైట్ల పొడవున్న స్టాక్ విభాగం యొక్క ఖాళీ ప్రాంతానికి సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"We call the word of memory pointed to by SP the top of the stack.","translation":"SP ద్వారా సూచించబడిన మెమరీ పదాన్ని మేము స్టాక్ యొక్క పైభాగం అని పిలుస్తాము.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"One thing to remember is that PUSHA is a newer instruction that doesn't exist on the 8086 and 8088.","translation":"గుర్తుంచుకోవలసిన ఒక విషయం ఏమిటంటే PUSHA అనేది 8086 మరియు 8088లో లేని కొత్త సూచన.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In real mode segmented model, the stack exists in a separate segment.","translation":"నిజమైన మోడ్ విభజిత నమూనాలో, స్టాక్ ప్రత్యేక విభాగంలో ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"What can and cannot be pushed onto the stack is complicated and depends on what CPU you're using.","translation":"స్టాక్పై ఏమి నెట్టవచ్చు మరియు ఏమి నెట్టలేము అనేది సంక్లిష్టంగా ఉంటుంది మరియు మీరు ఉపయోగిస్తున్న CPUపై ఆధారపడి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Stack crashes are serious business, at least in part because there is only one stack in action at a time in real mode.","translation":"స్టాక్ క్రాష్లు తీవ్రమైన వ్యాపారం, కనీసం కొంతమేరకు ఎందుకంటే నిజమైన మోడ్లో ఒక సమయంలో ఒకే స్టాక్ మాత్రమే ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In general, what gets pushed must get popped, or you can end up in any of several different kinds of trouble.","translation":"సాధారణంగా, ఏమి నెట్టబడుతుందో అది పాప్ చేయబడాలి, లేదా మీరు అనేక రకాల సమస్యలలో ముగుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Getting a word of data off the stack is done with another trio of instructions, POP, POPF, and POPA.","translation":"స్టాక్ నుండి డేటా పదాన్ని పొందడం POP, POPF మరియు POPA అనే మరో మూడు సూచనలతో చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"As with PUSH, POP only operates on word-sized operands.","translation":"PUSH వలె, POP కూడా పదం-పరిమాణ ఆపరేండ్లపై మాత్రమే పనిచేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"First the word of data at SS:SP is copied from the stack and placed in POP's operand, whatever you specified that to be.","translation":"ముందుగా SS:SP వద్ద ఉన్న డేటా పదం స్టాక్ నుండి కాపీ చేయబడుతుంది మరియు POP యొక్క ఆపరేండ్లో ఉంచబడుతుంది, మీరు దేనినైనా పేర్కొన్నారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It's significant that SP is decremented before placing a word on the stack at push time, but incremented after removing a word from the stack at pop time.","translation":"పుష్ సమయంలో స్టాక్పై ఒక పదాన్ని ఉంచే ముందు SP తగ్గించబడటం ముఖ్యం, అయితే పాప్ సమయంలో స్టాక్ నుండి ఒక పదాన్ని తీసివేసిన తర్వాత పెంచబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Ordinarily, you don't have to remember that fact, as PUSH and POP handle it all for you and you don't have to manually keep track of what SP is pointing to.","translation":"సాధారణంగా, మీరు ఆ విషయాన్ని గుర్తుంచుకోవలసిన అవసరం లేదు, ఎందుకంటే PUSH మరియు POP మీ కోసం అన్నీ నిర్వహిస్తాయి మరియు SP దేనికి సూచిస్తుందో మీరు మానవీయంగా ట్రాక్ చేయనవసరం లేదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The stack should be considered a place to stash things for the short term.","translation":"స్టాక్ను స్వల్పకాలికంగా విషయాలను దాచుకునే ప్రదేశంగా పరిగణించాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If you need a register to temporarily hold some value to be operated on by the CPU and all the registers are in use, push one of the busy registers onto the stack.","translation":"మీకు CPU ద్వారా నిర్వహించబడే కొన్ని విలువలను తాత్కాలికంగా కలిగి ఉండటానికి ఒక రిజిస్టర్ అవసరమైతే మరియు అన్ని రిజిస్టర్లు వాడుకలో ఉంటే, బిజీ రిజిస్టర్లలో ఒకదాన్ని స్టాక్పైకి నెట్టండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In moving 09H into register AH, we tell the dispatcher which service we want performed.","translation":"09H ను AH రిజిస్టర్లోకి తరలించడం ద్వారా, మేము ఏ సేవను నిర్వహించాలనుకుంటున్నామో డిస్పాచర్కు తెలియజేస్తాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Service 09H is DOS's Print String service.","translation":"సేవ 09H అనేది DOS యొక్క ప్రింట్ స్ట్రింగ్ సేవ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This is not the fastest nor in other ways the best way to display a string on the PC's screen, but it is most certainly the easiest.","translation":"ఇది PC స్క్రీన్పై స్ట్రింగ్ను ప్రదర్శించడానికి వేగవంతమైనది కాదు లేదా ఇతర మార్గాల్లో ఉత్తమమైనది కాదు, కానీ ఇది ఖచ్చితంగా సులభమైనది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"DOS service 09H has a slightly odd requirement: That the end of the string be marked with a dollar sign ($).","translation":"DOS సేవ 09Hకి కొంచెం విచిత్రమైన అవసరం ఉంది: స్ట్రింగ్ ముగింపు డాలర్ గుర్తుతో ($) గుర్తించబడాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is the reason for the dollar sign hung incongruously on the end of EAT.ASM's advertising slogan string.","translation":"దీనికి కారణం EAT.ASM యొక్క ప్రకటన నినాద స్ట్రింగ్ చివరన డాలర్ గుర్తును అసమంజసంగా వేలాడదీయడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Given that DOS does not ask us to pass it a value indicating how long the string is, the end of the string has to be marked somehow, and the dollar sign is DOS's chosen way.","translation":"DOS స్ట్రింగ్ ఎంత పొడవుగా ఉందో సూచించే విలువను పాస్ చేయమని మమ్మల్ని అడగనందున, స్ట్రింగ్ ముగింపును ఎలాగోలా గుర్తించాలి మరియు డాలర్ గుర్తు DOS ఎంచుకున్న మార్గం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It's a lousy way, unfortunately, because with the dollar sign acting as a marker, there is no way to display a dollar sign.","translation":"దురదృష్టవశాత్తు ఇది ఒక చెత్త మార్గం, ఎందుకంటే డాలర్ గుర్తు మార్కర్గా పనిచేస్తుండగా, డాలర్ గుర్తును ప్రదర్శించడానికి మార్గం లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If you intend to talk about money on the PC's screen, don't use DOS service 9!","translation":"మీరు PC స్క్రీన్పై డబ్బు గురించి మాట్లాడాలని అనుకుంటే, DOS సేవ 9ని ఉపయోగించవద్దు!","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"As I said, this is the easiest, but certainly not the best way to display text on the screen.","translation":"నేను చెప్పినట్లుగా, ఇది సులభమైనది, కానీ స్క్రీన్పై వచనాన్ని ప్రదర్శించడానికి ఉత్తమ మార్గం కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"With the address of the string in DS:DX and service number 09H in AH, we take a trip to the dispatcher by executing INT 21H.","translation":"DS:DXలో స్ట్రింగ్ చిరునామా మరియు AHలో సర్వీస్ నంబర్ 09Hతో, INT 21Hని అమలు చేయడం ద్వారా మేము డిస్పాచర్కు వెళ్తాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The INT instruction is all it takes—boom!, and DOS has control, reading the string at DS:DX and sending it to the screen through mechanisms it keeps more or less to itself.","translation":"INT సూచనకు ఇది సరిపోతుంది—బూమ్!, మరియు DOS నియంత్రణను కలిగి ఉంది, DS:DX వద్ద స్ట్రింగ్ను చదువుతుంది మరియు దానిని స్క్రీన్కు పంపుతుంది, ఇది దాదాపుగా తనకే ఉంచుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"How do we get home again?","translation":"మనం మళ్ళీ ఇంటికి ఎలా వెళ్ళాలి?","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The address in vector 21H took control into DOS, but how does DOS know where to go to pass execution back into EAT.EXE?","translation":"వెక్టర్ 21Hలోని చిరునామా DOSలోకి నియంత్రణను తీసుకుంది, అయితే EAT.EXEలోకి ఎగ్జిక్యూషన్ను తిరిగి పంపడానికి DOS ఎక్కడికి వెళ్ళాలో ఎలా తెలుసు?","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"To get into DOS, a program looks in a completely reliable place for the address of where it wants to go: the address stored in vector 21H.","translation":"DOSలోకి ప్రవేశించడానికి, ఒక ప్రోగ్రామ్ ఎక్కడికి వెళ్లాలనుకుంటుందో దాని చిరునామా కోసం పూర్తిగా నమ్మదగిన స్థలంలో చూస్తుంది: వెక్టర్ 21Hలో నిల్వ చేయబడిన చిరునామా.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This address takes execution deep into DOS, leaving the program sitting above DOS.","translation":"ఈ చిరునామా అమలును DOS లోతుల్లోకి తీసుకువెళుతుంది, ప్రోగ్రామ్ను DOS పైన ఉంచుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"To continue execution where it left off prior to the INT 21 instruction, DOS has to look in a completely reliable place for the return address, and that completely reliable place is none other than the top of the stack.","translation":"INT 21 సూచనకు ముందు అది ఎక్కడ ఆగిపోయిందో అక్కడ అమలును కొనసాగించడానికి, DOS తిరిగి వచ్చే చిరునామా కోసం పూర్తిగా నమ్మదగిన స్థలంలో చూడాలి మరియు ఆ పూర్తిగా నమ్మదగిన స్థలం స్టాక్ యొక్క పైభాగం తప్ప మరొకటి కాదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"I mentioned earlier (without much emphasis) that the INT 21 instruction pushes an address to the top of the stack before it launches off into the unknown.","translation":"INT 21 సూచన తెలియని వాటిలోకి ప్రవేశించే ముందు స్టాక్ పైభాగానికి ఒక చిరునామాను నెట్టివేస్తుందని నేను ఇంతకు ముందు (ఎక్కువ ప్రాధాన్యత ఇవ్వకుండా) చెప్పాను.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This address is the address of the next instruction in line for execution: the instruction immediately following the INT 21 instruction.","translation":"ఈ చిరునామా అమలు కోసం వరుసలో ఉన్న తదుపరి సూచన యొక్క చిరునామా: INT 21 సూచనను వెంటనే అనుసరించే సూచన.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This location is completely reliable because, just as there is only one interrupt vector table in the machine, there is only one stack in operation at any one time.","translation":"ఈ స్థానం పూర్తిగా నమ్మదగినది, ఎందుకంటే, మెషీన్లో ఒకే అంతరాయ వెక్టర్ పట్టిక ఉన్నట్లే, ఏ సమయంలోనైనా ఒకే స్టాక్ మాత్రమే పనిచేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This means that there is only one top of the stack—that is, SS:SP—and DOS can always send execution back to the program that called it by popping the address off the top of the stack and jumping to that address.","translation":"అంటే స్టాక్ యొక్క ఒకే పైభాగం ఉంది—అంటే, SS:SP—మరియు DOS ఎల్లప్పుడూ చిరునామాను స్టాక్ పై నుండి తీసివేసి, ఆ చిరునామాకు వెళ్లడం ద్వారా దాన్ని పిలిచిన ప్రోగ్రామ్కు అమలును తిరిగి పంపవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each instruction uses some number of those cycles to do its work, and the number varies all over the map.","translation":"ప్రతి సూచన దాని పని చేయడానికి ఆ చక్రాలలో కొంత భాగాన్ని ఉపయోగిస్తుంది మరియు సంఖ్య అంతటా మారుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Knowing the cycle requirements for individual instructions is rarely sufficient to allow even an expert assembly language programmer to calculate how much time a given series of instructions will take.","translation":"ఒక్కొక్క సూచనకు ఎన్ని చక్రాలు అవసరమో తెలుసుకోవడం వల్ల నిపుణులైన అసెంబ్లీ భాషా ప్రోగ్రామర్కు కూడా సూచనల శ్రేణి ఎంత సమయం తీసుకుంటుందో లెక్కించడానికి సరిపోదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Flags is a veritable junk drawer of disjointed little bits of information, and it's tough to just sit down and describe all of them in detail at once.","translation":"ఫ్లాగ్లు విడిపోయిన చిన్న సమాచార బిట్ల యొక్క నిజమైన జంక్ డ్రాయర్, మరియు వాటినన్నింటినీ ఒకేసారి కూర్చుని వివరంగా వివరించడం కష్టం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A flag is a single bit of information whose meaning is independent from any other bit.","translation":"ఒక ఫ్లాగ్ అనేది ఒకే సమాచార బిట్, దీని అర్థం ఏదైనా ఇతర బిట్తో సంబంధం లేకుండా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The idea is to tell you, the programmer, the state of certain conditions inside the CPU, so that your program can test for and act on the states of those conditions.","translation":"CPU లోపల కొన్ని పరిస్థితుల స్థితిని ప్రోగ్రామర్కు తెలియజేయడమే దీని ఆలోచన, తద్వారా మీ ప్రోగ్రామ్ ఆ పరిస్థితుల స్థితులను పరీక్షించగలదు మరియు వాటిపై చర్య తీసుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each of the Flags register's nine flags has a two-letter symbol by which most programmers know them.","translation":"ఫ్లాగ్స్ రిజిస్టర్ యొక్క తొమ్మిది ఫ్లాగ్లలో ప్రతి ఒక్కటి రెండు అక్షరాల చిహ్నాన్ని కలిగి ఉంటాయి, దీని ద్వారా చాలా మంది ప్రోగ్రామర్లు వాటిని గుర్తిస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The Overflow flag is set when the result of an operation becomes too large to fit in the operand it originally occupied.","translation":"ఒక ఆపరేషన్ యొక్క ఫలితం అది మొదట ఆక్రమించిన ఆపరేండ్లో సరిపోయేంత పెద్దదిగా మారినప్పుడు ఓవర్ఫ్లో ఫ్లాగ్ సెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It dictates the direction that activity moves during the execution of string instructions.","translation":"స్ట్రింగ్ సూచనలను అమలు చేసేటప్పుడు కార్యాచరణ ఏ దిశలో కదులుతుందో ఇది నిర్దేశిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When DF is set, string instructions proceed from high memory toward low memory.","translation":"DF సెట్ చేసినప్పుడు, స్ట్రింగ్ సూచనలు అధిక మెమరీ నుండి తక్కువ మెమరీ వైపుకు వెళ్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When IF is set, interrupts are enabled and may occur when requested.","translation":"IF సెట్ చేసినప్పుడు, అంతరాయాలు ప్రారంభించబడతాయి మరియు అభ్యర్థించినప్పుడు సంభవించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When set, the Trap flag allows DEBUG's Trace command to do what it does, by forcing the CPU to execute only a single instruction before calling an interrupt routine.","translation":"సెట్ చేసినప్పుడు, ట్రాప్ ఫ్లాగ్ DEBUG యొక్క ట్రేస్ కమాండ్ ఒక అంతరాయ రొటీన్ను పిలిచే ముందు CPUని ఒకే సూచనను మాత్రమే అమలు చేయడానికి బలవంతం చేయడం ద్వారా అది చేసే పనిని చేయడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The Sign flag becomes set when the result of an operation forces the operand to become negative.","translation":"ఒక ఆపరేషన్ యొక్క ఫలితం ఆపరేండ్ను ప్రతికూలంగా మార్చడానికి బలవంతం చేసినప్పుడు సైన్ ఫ్లాగ్ సెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The Zero flag becomes set when the results of an operation become zero.","translation":"ఒక ఆపరేషన్ యొక్క ఫలితాలు సున్నా అయినప్పుడు జీరో ఫ్లాగ్ సెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The Auxiliary carry flag is used only for BCD arithmetic.","translation":"సహాయక క్యారీ ఫ్లాగ్ BCD అంకగణితానికి మాత్రమే ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The Parity flag will seem instantly familiar to anyone who understands serial data communications, and utterly bizarre to anyone who doesn't.","translation":"సీరియల్ డేటా కమ్యూనికేషన్లను అర్థం చేసుకున్న ఎవరికైనా పారిటీ ఫ్లాగ్ తక్షణమే సుపరిచితం అవుతుంది మరియు అర్థం చేసుకోలేని వారికి పూర్తిగా విచిత్రంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If the result of an arithmetic or shift operation \"carries out\" a bit from the operand, CF becomes set.","translation":"ఒక అంకగణిత లేదా షిఫ్ట్ ఆపరేషన్ ఆపరేండ్ నుండి ఒక బిట్ను ","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"You must remember that the descriptions of the flags on the previous pages are generalizations only and are subject to specific restrictions and special cases imposed by individual instructions.","translation":"మునుపటి పేజీలలోని ఫ్లాగ్ల వివరణలు సాధారణీకరణలు మాత్రమేనని మరియు వ్యక్తిగత సూచనల ద్వారా విధించబడిన నిర్దిష్ట పరిమితులు మరియు ప్రత్యేక కేసులకు లోబడి ఉంటాయని మీరు గుర్తుంచుకోవాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Flag etiquette for individual flags varies widely from instruction to instruction, even though the sense of the flag's use may be the same in every case.","translation":"వ్యక్తిగత ఫ్లాగ్ల కోసం ఫ్లాగ్ మర్యాద సూచన నుండి సూచనకు విస్తృతంగా మారుతుంది, అయినప్పటికీ ఫ్లాగ్ యొక్క ఉపయోగం యొక్క భావం ప్రతి సందర్భంలోనూ ఒకే విధంగా ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Adding one to something or subtracting one from something are actions that happen a lot in computer programming.","translation":"ఒకదానికి ఒకటి కలపడం లేదా ఒకదాని నుండి ఒకటి తీసివేయడం అనేది కంప్యూటర్ ప్రోగ్రామింగ్లో చాలా జరిగే చర్యలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If you're counting the number of times a program is executing a loop, or counting bytes in a table, or doing something that advances or retreats one count at a time, INC or DEC can be very quick ways to make the actual addition or subtraction happen.","translation":"మీరు ఒక ప్రోగ్రామ్ లూప్ను అమలు చేస్తున్న సమయాలను లెక్కిస్తుంటే, లేదా టేబుల్లోని బైట్లను లెక్కిస్తుంటే, లేదా ఒక సమయంలో ఒక కౌంట్ను ముందుకు లేదా వెనుకకు తీసుకువెళుతుంటే, INC లేదా DEC వాస్తవంగా కూడిక లేదా తీసివేతను చేయడానికి చాలా వేగవంతమైన మార్గాలు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Incrementing 0FFFFH, on the other hand, rolls over the register to 0 since 0FFFFH is the largest unsigned value that can be expressed in a 16-bit register.","translation":"మరోవైపు, 0FFFFHని ఇంక్రిమెంట్ చేయడం వలన రిజిస్టర్ 0కి రోల్ అవుతుంది, ఎందుకంటే 0FFFFH అనేది 16-బిట్ రిజిస్టర్లో వ్యక్తీకరించగల అతిపెద్ద సంతకం లేని విలువ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The difference with INC is that there is no carry.","translation":"INCతో ఉన్న వ్యత్యాసం ఏమిటంటే, క్యారీ లేదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When the result of an operation becomes zero, ZF is almost always set.","translation":"ఒక ఆపరేషన్ యొక్క ఫలితం సున్నా అయినప్పుడు, ZF దాదాపు ఎల్లప్పుడూ సెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Apart from looking at a reference guide, how can you tell what flags are affected by a given instruction?","translation":"సూచన గైడ్ను చూడటం కాకుండా, ఇచ్చిన సూచన ద్వారా ఏ ఫ్లాగ్లు ప్రభావితమవుతాయో మీరు ఎలా చెప్పగలరు?","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each keystroke you type on the keyboard triggers an interrupt.","translation":"మీరు కీబోర్డ్లో టైప్ చేసే ప్రతి కీస్ట్రోక్ ఒక అంతరాయాన్ని ప్రేరేపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Each time you execute an instruction with the Trace command, the flags display will be updated.","translation":"మీరు ట్రేస్ కమాండ్తో ఒక సూచనను అమలు చేసిన ప్రతిసారీ, ఫ్లాగ్ల ప్రదర్శన నవీకరించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Five out of nine flags are affected by every INC and DEC instruction that the CPU executes.","translation":"CPU అమలు చేసే ప్రతి INC మరియు DEC సూచన ద్వారా తొమ్మిది ఫ్లాగ్లలో ఐదు ప్రభావితమవుతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Thorough understanding of the flags comes with practice and dogged persistence.","translation":"ఫ్లాగ్ల గురించి పూర్తిగా అర్థం చేసుకోవడం సాధన మరియు పట్టుదలతో వస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Back on the sample reference appendix page (see page 212), notice the following example uses of the NEG instruction:","translation":"నమూనా సూచన అనుబంధ పేజీలో (పేజీ 212 చూడండి), NEG సూచన యొక్క క్రింది ఉదాహరణలను గమనించండి:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"They exist in the broad class of things we call directives.","translation":"అవి మనం ఆదేశాలు అని పిలిచే విషయాల యొక్క విస్తృత తరగతిలో ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The memory data operand [BX] only specifies an address in memory, using DS as the assumed segment register.","translation":"మెమరీ డేటా ఆపరేండ్ [BX] DSని ఊహించిన సెగ్మెంట్ రిజిస్టర్గా ఉపయోగించి, మెమరీలో ఒక చిరునామాను మాత్రమే పేర్కొంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The assembler is unconcerned with what an assembly language variable means.","translation":"అసెంబ్లర్ అసెంబ్లీ భాషా వేరియబుల్ అర్థం ఏమిటో పట్టించుకోదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Register data always has a fixed and obvious type, since a register's size cannot be changed.","translation":"రిజిస్టర్ పరిమాణం మార్చలేనందున, రిజిస్టర్ డేటా ఎల్లప్పుడూ స్థిరమైన మరియు స్పష్టమైన రకాన్ని కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The assembler does not want to have to try to fit 10 pounds of kitty litter in a 5-pound bag, which is impossible, nor 5 pounds of kitty litter in a 10-pound bag, which can be confusing and under some circumstances possibly dangerous.","translation":"అసెంబ్లర్ 10 పౌండ్ల కిట్టి లిట్టర్ను 5-పౌండ్ల బ్యాగ్లో ఉంచడానికి ప్రయత్నించకూడదనుకుంటుంది, ఇది అసాధ్యం, లేదా 5 పౌండ్ల కిట్టి లిట్టర్ను 10-పౌండ్ల బ్యాగ్లో ఉంచకూడదనుకుంటుంది, ఇది గందరగోళంగా ఉంటుంది మరియు కొన్ని పరిస్థితులలో ప్రమాదకరంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Here, Counter is a variable allocated as a single byte in memory by the DB (Define Byte) directive.","translation":"ఇక్కడ, కౌంటర్ అనేది DB (డెఫైన్ బైట్) ఆదేశం ద్వారా మెమరీలో ఒకే బైట్గా కేటాయించబడిన వేరియబుల్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The assembler will give you an error message if you reference a label without defining it.","translation":"మీరు లేబుల్ను నిర్వచించకుండా సూచిస్తే, అసెంబ్లర్ మీకు లోపం సందేశాన్ని ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In modular programming, you're frequently going to be calling procedures that don't exist anywhere in the program that you're actually working on.","translation":"మాడ్యులర్ ప్రోగ్రామింగ్లో, మీరు వాస్తవానికి పని చేస్తున్న ప్రోగ్రామ్లో ఎక్కడా లేని విధానాలను తరచుగా పిలుస్తారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The answer is to break the utility procedures out into an external library.","translation":"సమాధానం ఏమిటంటే యుటిలిటీ విధానాలను బాహ్య లైబ్రరీగా మార్చడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is called modular programming, and it is an extremely effective tool for programming efficiently.","translation":"దీనిని మాడ్యులర్ ప్రోగ్రామింగ్ అంటారు మరియు ఇది సమర్ధవంతంగా ప్రోగ్రామింగ్ చేయడానికి చాలా ప్రభావవంతమైన సాధనం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each .ASM file is considered a module.","translation":"ప్రతి .ASM ఫైల్ ఒక మాడ్యూల్గా పరిగణించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The linker weaves all of the .OBJ files together.","translation":"అన్ని .OBJ ఫైల్లను లింకర్ ఒకచోట చేర్చుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The assembler is told that a given label will have to be found outside the program.","translation":"ఒక నిర్దిష్ట లేబుల్ ప్రోగ్రామ్ వెలుపల కనుగొనబడాలని అసెంబ్లర్కు చెప్పబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You have to warn the assembler that ClrScr will be referenced from outside the module.","translation":"ClrScr మాడ్యూల్ వెలుపల నుండి సూచించబడుతుందని మీరు అసెంబ్లర్కు హెచ్చరించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker does that during the link operation.","translation":"లింక్ ఆపరేషన్ సమయంలో లింకర్ అది చేస్తాడు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"At link time, the linker takes the two .OBJ files and combines them into a single .EXE executable file.","translation":"లింక్ సమయంలో, లింకర్ రెండు .OBJ ఫైల్లను తీసుకుని వాటిని ఒకే .EXE ఎగ్జిక్యూటబుల్ ఫైల్గా మిళితం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"What works for procedures works for data as well.","translation":"విధానాలకు పనిచేసేది డేటాకు కూడా పనిచేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"External modules do not contain a main program.","translation":"బాహ్య మాడ్యూల్స్ ప్రధాన ప్రోగ్రామ్ను కలిగి ఉండవు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"External modules have no stack segment.","translation":"బాహ్య మాడ్యూల్స్కు స్టాక్ విభాగం లేదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"External modules may have a data segment.","translation":"బాహ్య మాడ్యూల్స్కు డేటా విభాగం ఉండవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Make your module segments public if they contain any public declarations!","translation":"మీ మాడ్యూల్ విభాగాలను పబ్లిక్గా చేయండి, అవి ఏదైనా పబ్లిక్ డిక్లరేషన్లను కలిగి ఉంటే!","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The code segment contains all the procedures declared as GLOBAL.","translation":"కోడ్ విభాగంలో GLOBALగా ప్రకటించబడిన అన్ని విధానాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"VIDLIB.ASM declares no variables of its own.","translation":"VIDLIB.ASM దాని స్వంత వేరియబుల్స్ను ప్రకటించదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"NASM is case-sensitive for variable names and labels.","translation":"వేరియబుల్ పేర్లు మరియు లేబుల్ల కోసం NASM కేస్-సెన్సిటివ్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The program as a whole contains only one code segment and one data segment.","translation":"ప్రోగ్రామ్ మొత్తం మీద ఒక కోడ్ విభాగం మరియు ఒక డేటా విభాగాన్ని మాత్రమే కలిగి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The segments containing imported or exported items must be declared as public.","translation":"దిగుమతి చేయబడిన లేదా ఎగుమతి చేయబడిన అంశాలను కలిగి ఉన్న విభాగాలు పబ్లిక్గా ప్రకటించబడాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It's nothing more than a simple text file containing the three commands you would need to type separately.","translation":"ఇది మీరు విడిగా టైప్ చేయవలసిన మూడు ఆదేశాలను కలిగి ఉన్న ఒక సాధారణ టెక్స్ట్ ఫైల్ మాత్రమే.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"To run this batch program, just type \"BUILD4\" at the DOS prompt.","translation":"ఈ బ్యాచ్ ప్రోగ్రామ్ను అమలు చేయడానికి, DOS ప్రాంప్ట్ వద్ద \"BUILD4\" అని టైప్ చేయండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You'll be able to follow the progress of the three program runs, including any error messages or warnings.","translation":"మీరు మూడు ప్రోగ్రామ్ అమలుల పురోగతిని, ఏవైనా లోపం సందేశాలు లేదా హెచ్చరికలతో సహా అనుసరించగలరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Declare the code segments PUBLIC in all modules, and give them all the same name.","translation":"అన్ని మాడ్యూల్స్లో కోడ్ విభాగాలను పబ్లిక్గా ప్రకటించండి మరియు వాటికి ఒకే పేరును ఇవ్వండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Declare all exported procedures, entry points, and variables as GLOBAL.","translation":"ఎగుమతి చేయబడిన అన్ని విధానాలు, ఎంట్రీ పాయింట్లు మరియు వేరియబుల్స్ను గ్లోబల్గా ప్రకటించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Put the exported declaration statement inside the segment where the exported items are declared.","translation":"ఎగుమతి చేయబడిన అంశాలు ప్రకటించబడిన విభాగంలో ఎగుమతి ప్రకటనను ఉంచండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Declare all imported procedures, entry points, and variables as EXTERN.","translation":"దిగుమతి చేసుకున్న అన్ని విధానాలు, ఎంట్రీ పాయింట్లు మరియు వేరియబుల్స్ను ఎక్స్టర్న్గా ప్రకటించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Data is used in the data segment, code in the code segment.","translation":"డేటాను డేటా విభాగంలో ఉపయోగిస్తారు, కోడ్ను కోడ్ విభాగంలో ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Finally, don't forget to add the names of all external modules to the linker command line in the link step.","translation":"చివరగా, లింక్ దశలో లింకర్ కమాండ్ లైన్కు అన్ని బాహ్య మాడ్యూల్స్ పేర్లను జోడించడం మర్చిపోవద్దు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If this still seems fuzzy to you, follow VIDLIB. ASM and EAT4. ASM as a model.","translation":"ఇది మీకు ఇంకా అస్పష్టంగా అనిపిస్తే, VIDLIB. ASM మరియు EAT4. ASMని ఒక నమూనాగా అనుసరించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Certainly it would be worth beefing up VIDLIB. ASM by adding more screen control procedures.","translation":"ఖచ్చితంగా, మరిన్ని స్క్రీన్ కంట్రోల్ విధానాలను జోడించడం ద్వారా VIDLIB. ASMని మెరుగుపరచడం విలువైనది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Procedures are the most obvious way, and certainly the easiest to understand.","translation":"విధానాలు చాలా స్పష్టమైన మార్గం, మరియు ఖచ్చితంగా అర్థం చేసుకోవడానికి సులభమైనవి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Macros are a different breed of cat entirely.","translation":"మాక్రోలు పూర్తిగా భిన్నమైన కోవకు చెందినవి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When the assembler encounters the macro label in a source code file, it replaces the macro label with the text lines that the macro label represents.","translation":"అసెంబ్లర్ సోర్స్ కోడ్ ఫైల్లో మాక్రో లేబుల్ను ఎదుర్కొన్నప్పుడు, మాక్రో లేబుల్ సూచించే టెక్స్ట్ లైన్లతో మాక్రో లేబుల్ను భర్తీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Macros bear some resemblance to include files in high-level languages such as Pascal.","translation":"మాక్రోలు పాస్కల్ వంటి హై-లెవెల్ భాషలలోని ఫైల్లను చేర్చడానికి కొంత పోలికను కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You might think of a macro as an include file that's built right into the source code file.","translation":"మీరు మాక్రోను సోర్స్ కోడ్ ఫైల్లో నిర్మించిన ఫైల్ను చేర్చినట్లుగా భావించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There are advantages to macros over procedures.","translation":"విధానాల కంటే మాక్రోలకు కొన్ని ప్రయోజనాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In a macro, neither instruction is used.","translation":"ఒక మాక్రోలో, ఏ సూచన ఉపయోగించబడదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"By and large, think macros for speed and procedures for compactness.","translation":"మొత్తం మీద, వేగం కోసం మాక్రోల గురించి మరియు కాంపాక్ట్నెస్ కోసం విధానాల గురించి ఆలోచించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A macro definition looks a little like a procedure definition, framed between a pair of directives: %macro and %endmacro.","translation":"ఒక మాక్రో నిర్వచనం %macro మరియు %endmacro అనే ఆదేశాల మధ్య ఫ్రేమ్ చేయబడిన విధానం నిర్వచనంగా కొద్దిగా కనిపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Set 16 bit code generation.","translation":"16 బిట్ కోడ్ ఉత్పత్తిని అమర్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Set code start address to 100h (COM file).","translation":"కోడ్ ప్రారంభ చిరునామాను 100h (COM ఫైల్)కి సెట్ చేయండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This is where program execution begins.","translation":"ఇక్కడే ప్రోగ్రామ్ అమలు ప్రారంభమవుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Position cursor.","translation":"కర్సర్ ఉంచండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"and display first text line.","translation":"మొదటి టెక్స్ట్ లైన్ను ప్రదర్శించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Terminate process DOS service.","translation":"ప్రక్రియను ముగించండి DOS సేవ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Pass this value back to ERRORLEVEL.","translation":"ఈ విలువను ERRORLEVELకి తిరిగి పంపండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Control returns to DOS.","translation":"DOSకి నియంత్రణ తిరిగి వస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Section containing initialized data.","translation":"ప్రారంభించబడిన డేటాను కలిగి ఉన్న విభాగం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Change to 0B0000000H if you have a mono CRT!","translation":"మీకు మోనో CRT ఉంటే 0B0000000Hకి మార్చుకోండి!","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The lesson is that there are numerous ways to skin a screen.","translation":"స్క్రీన్ను తీసేయడానికి అనేక మార్గాలు ఉన్నాయని పాఠం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It's starting to look like something other than an assembly language program.","translation":"ఇది అసెంబ్లీ భాషా ప్రోగ్రామ్ కాకుండా ఏదోలా కనిపిస్తోంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"I actually used such a language in my first job as a programmer.","translation":"ప్రోగ్రామర్గా నా మొదటి ఉద్యోగంలో నేను నిజంగా అలాంటి భాషను ఉపయోగించాను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The danger there is that unless you name your macros carefully and document them both in their macro library files and on the lines where they are invoked, your programs will not be any more comprehensible for their presence.","translation":"మీరు మీ స్థూలాలను జాగ్రత్తగా పేరు పెట్టకపోతే మరియు వాటిని వారి స్థూల లైబ్రరీ ఫైల్లలో మరియు అవి పిలువబడే లైన్లలో డాక్యుమెంట్ చేయకపోతే, మీ ప్రోగ్రామ్లు వాటి ఉనికి కోసం మరింత అర్థమయ్యేవి కావు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Dividing complexity into numerous compartments is only half the job-labeling the compartments is just as (or more) important!","translation":"సంక్లిష్టతను అనేక కంపార్ట్మెంట్లుగా విభజించడం సగం మాత్రమే - కంపార్ట్మెంట్లకు లేబుల్ చేయడం అంతే (లేదా అంతకంటే ఎక్కువ) ముఖ్యం!","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"I've found that machine instructions aren't the most important part of assembly language programming.","translation":"అసెంబ్లీ భాషా ప్రోగ్రామింగ్లో మెషిన్ సూచనలు చాలా ముఖ్యమైనవి కాదని నేను కనుగొన్నాను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Higher-level languages such as Pascal and Modula-2 hide much of those essential details from you.","translation":"పాస్కల్ మరియు మోడ్యులా-2 వంటి ఉన్నత స్థాయి భాషలు మీ నుండి ఆ ముఖ్యమైన వివరాలను చాలా దాచిపెడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In assembly language you must see to them yourself.","translation":"అసెంబ్లీ భాషలో మీరు వాటిని మీరే చూడాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If you've digested everything I've said so far, however, you're ready to get in and understand the remainder of the x86 instruction set.","translation":"అయితే, నేను ఇంతవరకు చెప్పిన ప్రతి విషయాన్ని మీరు జీర్ణించుకున్నట్లయితే, మీరు లోపలికి వెళ్లి x86 సూచన సెట్ను అర్థం చేసుకోవడానికి సిద్ధంగా ఉన్నారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The skills you need to build programming expertise are now yours, and if this book has accomplished that much, I'd say it's accomplished a lot.","translation":"ప్రోగ్రామింగ్ నైపుణ్యాన్ని నిర్మించడానికి మీకు అవసరమైన నైపుణ్యాలు ఇప్పుడు మీవే, మరియు ఈ పుస్తకం అంత సాధించి ఉంటే, అది చాలా సాధించిందని నేను చెప్తాను.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"continue, and tool building is a very good way to hone your assembly language skills.","translation":"కొనసాగించండి, మరియు టూల్ బిల్డింగ్ మీ అసెంబ్లీ భాషా నైపుణ్యాలను మెరుగుపరచడానికి చాలా మంచి మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"On the other hand, a short sequence (5 to 10 instructions) that is only called once or perhaps twice within a middling program is a poor candidate for a procedure.","translation":"మరోవైపు, ఒక మధ్యస్థ ప్రోగ్రామ్లో ఒకసారి లేదా రెండుసార్లు మాత్రమే పిలువబడే చిన్న సీక్వెన్స్ (5 నుండి 10 సూచనలు) ఒక విధానానికి పేలవమైన అభ్యర్థి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"You may find it useful to define large procedures that are called only once when your program becomes big enough to require breaking it down into functional chunks.","translation":"మీ ప్రోగ్రామ్ ఫంక్షనల్ ముక్కలుగా విభజించాల్సినంత పెద్దదిగా మారినప్పుడు ఒక్కసారి మాత్రమే పిలువబడే పెద్ద విధానాలను నిర్వచించడం మీకు ఉపయోగకరంగా అనిపించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A thousand-line assembly language program might split well into a sequence of 9 or 10 largish procedures.","translation":"వెయ్యి లైన్ల అసెంబ్లీ భాషా ప్రోగ్రామ్ 9 లేదా 10 పెద్ద విధానాల శ్రేణిగా బాగా విభజించబడవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each is only called once from the main program, but this allows your main program to be very indicative of what the program is doing.","translation":"ప్రతి ఒక్కటి ప్రధాన ప్రోగ్రామ్ నుండి ఒక్కసారి మాత్రమే పిలువబడుతుంది, కానీ ఇది మీ ప్రధాన ప్రోగ్రామ్ ప్రోగ్రామ్ ఏమి చేస్తుందో చాలా సూచికగా ఉండటానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is clean and readable and provides a necessary view from a height when you begin to approach a thousand-line assembly language program.","translation":"ఇది శుభ్రంగా మరియు చదవడానికి అనుకూలంగా ఉంటుంది మరియు మీరు వెయ్యి లైన్ల అసెంబ్లీ భాషా ప్రోగ్రామ్ను చేరుకోవడం ప్రారంభించినప్పుడు ఎత్తు నుండి అవసరమైన వీక్షణను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Remember that the Martians are always hiding somewhere close by, anxious to turn your program into unreadable hieroglyphics.","translation":"మార్టియన్లు ఎల్లప్పుడూ ఎక్కడో దాగి ఉంటారని గుర్తుంచుకోండి, మీ ప్రోగ్రామ్ను చదవలేని చిత్రలిపిగా మార్చడానికి ఆత్రుతగా ఉన్నారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"There's no weapon against them with half the power of procedures.","translation":"విధానాల సగం శక్తితో వారికి వ్యతిరేకంగా ఎటువంటి ఆయుధం లేదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Using BIOS Services In the last chapter we looked closely at DOS services, which are accessed through the DOS services dispatcher.","translation":"BIOS సేవలను ఉపయోగించడం గత అధ్యాయంలో మేము DOS సేవలపై నిశితంగా చూశాము, ఇవి DOS సేవల డిస్పాచర్ ద్వారా యాక్సెస్ చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The DOS dispatcher lives at the other end of software interrupt 21H and offers a tremendous list of services at the disposal of your programs.","translation":"DOS డిస్పాచర్ సాఫ్ట్వేర్ అంతరాయం 21H యొక్క మరొక చివరన ఉంది మరియు మీ ప్రోగ్రామ్ల వద్ద పారవేయడానికి అపారమైన సేవల జాబితాను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"There's another provider of services in your machine that lives even deeper than DOS: the ROM BIOS.","translation":"మీ మెషీన్లో DOS కంటే లోతుగా నివసించే మరొక సేవల ప్రొవైడర్ ఉంది: ROM BIOS.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"ROM is an acronym for read-only memory, and it indicates memory chips whose contents are burned into their silicon and do not vanish when power is turned off.","translation":"ROM అనేది రీడ్-ఓన్లీ మెమరీకి సంక్షిప్త రూపం, మరియు ఇది మెమరీ చిప్లను సూచిస్తుంది, వీటి విషయాలు వాటి సిలికాన్లోకి కాల్చబడతాయి మరియు పవర్ ఆఫ్ చేసినప్పుడు అదృశ్యం కావు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"BIOS is an acronym for Basic Input/Output System, and it is just that: a collection of fundamental routines for dealing with your computer's input and output peripherals.","translation":"BIOS అనేది బేసిక్ ఇన్పుట్/అవుట్పుట్ సిస్టమ్ యొక్క సంక్షిప్త రూపం, మరియు ఇది అంతే: మీ కంప్యూటర్ యొక్క ఇన్పుట్ మరియు అవుట్పుట్ పెరిఫెరల్స్తో వ్యవహరించే ప్రాథమిక దినచర్యల సమాహారం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"These include disk drives, displays, printers, and the like.","translation":"వీటిలో డిస్క్ డ్రైవ్లు, డిస్ప్లేలు, ప్రింటర్లు మరియు మొదలైనవి ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"DOS uses BIOS services as part of some of the services that it provides.","translation":"DOS ఇది అందించే కొన్ని సేవలలో భాగంగా BIOS సేవలను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Like DOS, BIOS services are accessed through software interrupts.","translation":"DOS వలె, BIOS సేవలు సాఫ్ట్వేర్ అంతరాయాల ద్వారా యాక్సెస్ చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Unlike DOS, which channels nearly all requests for its services through the single interrupt 21H, BIOS uses numerous interrupts (about 10) and groups similar categories of services beneath the control of different interrupts.","translation":"DOS వలె కాకుండా, ఇది తన సేవల కోసం దాదాపు అన్ని అభ్యర్థనలను ఒకే అంతరాయం 21H ద్వారా ఛానెల్ చేస్తుంది, BIOS అనేక అంతరాయాలను (సుమారు 10) ఉపయోగిస్తుంది మరియు విభిన్న అంతరాయాల నియంత్రణలో సారూప్య సేవల వర్గాలను సమూహపరుస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"For example, video display services are accessed through interrupt 10H, keyboard services come through interrupt 16H, printer services through interrupt 17H, and so on.","translation":"ఉదాహరణకు, వీడియో డిస్ప్లే సేవలు అంతరాయం 10H ద్వారా యాక్సెస్ చేయబడతాయి, కీబోర్డ్ సేవలు అంతరాయం 16H ద్వారా వస్తాయి, ప్రింటర్ సేవలు అంతరాయం 17H ద్వారా వస్తాయి మరియు మొదలైనవి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The overall method for using BIOS services, however, is very similar to that of DOS.","translation":"BIOS సేవలను ఉపయోగించే మొత్తం పద్ధతి, అయితే, DOS వలె చాలా పోలి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You load a service number and sometimes other initial values into the registers and then execute an INT <n> instruction, where the n depends on the category of services you're requesting.","translation":"మీరు ఒక సేవా సంఖ్యను మరియు కొన్నిసార్లు ఇతర ప్రారంభ విలువలను రిజిస్టర్లలోకి లోడ్ చేస్తారు, ఆపై INT <n> సూచనను అమలు చేస్తారు, ఇక్కడ n మీరు అభ్యర్థిస్తున్న సేవల వర్గాన్ని బట్టి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The high bit of the quantity indicates if the number is negative.","translation":"సంఖ్య యొక్క అధిక బిట్ ఆ సంఖ్య రుణాత్మకమా కాదా అని సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Signed arithmetic in assembly language is complex.","translation":"అసెంబ్లీ భాషలో సంతకం చేసిన అంకగణితం సంక్లిష్టంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Unsigned arithmetic does not recognize negative numbers.","translation":"అన్సైన్డ్ అంకగణితం ప్రతికూల సంఖ్యలను గుర్తించదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Signed values are considered greater than or less than.","translation":"సంతకం చేసిన విలువలు ఎక్కువ లేదా తక్కువగా పరిగణించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Unsigned values are considered above or below.","translation":"అన్సైన్డ్ విలువలు పైన లేదా క్రింద పరిగణించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Use JG (Jump if Greater) after a CMP instruction.","translation":"CMP సూచన తర్వాత JG (ఎక్కువ అయితే జంప్) ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Use JA (Jump if Above) after a CMP instruction.","translation":"CMP సూచన తర్వాత JA (పైన ఉంటే జంప్) ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Table 10.6 summarizes the arithmetic jump mnemonics.","translation":"టేబుల్ 10.6 అంకగణిత జంప్ న్యుమోనిక్స్ను సంగ్రహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Any mnemonics containing the words above or below are for unsigned values.","translation":"పైన లేదా క్రింద అనే పదాలను కలిగి ఉన్న ఏదైనా న్యుమోనిక్స్ అన్సైన్డ్ విలువల కోసం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Any mnemonics containing the words greater or less are for signed values.","translation":"ఎక్కువ లేదా తక్కువ అనే పదాలను కలిగి ఉన్న ఏదైనా న్యుమోనిక్స్ సంతకం చేసిన విలువల కోసం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The mnemonics with their synonyms represent opposite viewpoints.","translation":"సమానార్థకాలు కలిగిన న్యుమోనిక్స్ వ్యతిరేక అభిప్రాయాలను సూచిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Table 10.7 sorts the mnemonics by logical condition.","translation":"టేబుల్ 10.7 తార్కిక పరిస్థితి ద్వారా న్యుమోనిక్స్ను క్రమబద్ధీకరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The Zero flag is set to 1 if the result is 0.","translation":"ఫలితం 0 అయితే, సున్నా ఫ్లాగ్ 1కి సెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"JE and JZ mnemonics are synonyms.","translation":"JE మరియు JZ న్యుమోనిక్స్ పర్యాయపదాలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"JNE and JNZ are synonyms.","translation":"JNE మరియు JNZ పర్యాయపదాలు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Detecting the installed display adapter is a useful example.","translation":"ఇన్స్టాల్ చేయబడిన డిస్ప్లే అడాప్టర్ను గుర్తించడం ఒక ఉపయోగకరమైన ఉదాహరణ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The VGA and MCGA were introduced with the PS/2 series in 1987.","translation":"VGA మరియు MCGA 1987లో PS/2 సిరీస్తో ప్రవేశపెట్టబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The way a certain board operates can change severely.","translation":"ఒక నిర్దిష్ట బోర్డు పనిచేసే విధానం తీవ్రంగా మారవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The most obvious difference is the memory address of the video display buffer.","translation":"అత్యంత స్పష్టమైన వ్యత్యాసం వీడియో డిస్ప్లే బఫర్ యొక్క మెమరీ చిరునామా.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"DispID identifies the installed display adapter.","translation":"DispID ఇన్స్టాల్ చేయబడిన డిస్ప్లే అడాప్టర్ను గుర్తిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The low nybble of the value to be converted is now in DI.","translation":"మార్చవలసిన విలువ యొక్క తక్కువ నైబుల్ ఇప్పుడు DI లో ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The address of Digits is loaded into BX.","translation":"అంకెల చిరునామా BX లోకి లోడ్ చేయబడింది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Then the appropriate digit character is copied from Digits into AH.","translation":"అప్పుడు తగిన అంకెల అక్షరం అంకెలనుండి AH లోకి కాపీ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The whole trick of using a lookup table lies in the way the character in the table is addressed.","translation":"ఒక లుకప్ టేబుల్ ఉపయోగించడం వెనుక ఉన్న మొత్తం రహస్యం ఏమిటంటే, పట్టికలోని అక్షరాన్ని ఎలా పరిష్కరించాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"DS:BX points to the start of Digits, so [BX] would address the first character in Digits.","translation":"DS:BX అంకెల ప్రారంభానికి సూచిస్తుంది, కాబట్టి [BX] అంకెలలోని మొదటి అక్షరాన్ని పరిష్కరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"To get at the desired digit, we must index into the lookup table by adding the offset into the table to BX.","translation":"కావలసిన అంకెను పొందడానికి, మనం BXకి పట్టికలోని ఆఫ్సెట్ను జోడించడం ద్వారా లుకప్ టేబుల్లోకి సూచికను చేర్చాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"There is an x86 addressing mode intended precisely for use with lookup tables, called base indexed addressing.","translation":"లుకప్ టేబుల్లతో ఖచ్చితంగా ఉపయోగించడానికి ఉద్దేశించిన x86 అడ్రసింగ్ మోడ్ ఉంది, దీనిని బేస్ ఇండెక్స్డ్ అడ్రసింగ్ అంటారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If you recall, we masked out all of DI but the four lowest bits of the byte we are converting.","translation":"మీకు గుర్తుంటే, మనం మారుస్తున్న బైట్ యొక్క నాలుగు తక్కువ బిట్లను మినహాయించి, DIలోని వాటన్నింటినీ మాస్క్ చేసాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"These bits will contain some value from 0 through 0FH.","translation":"ఈ బిట్లు 0 నుండి 0FH వరకు కొంత విలువను కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Digits contains the hexadecimal digit characters from 0 to F.","translation":"అంకెలు 0 నుండి F వరకు ఉన్న హెక్సాడెసిమల్ అంకెల అక్షరాలను కలిగి ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"By using DI as the index, the value in DI will select its corresponding digit character in Digits.","translation":"సూచికగా DIని ఉపయోగించడం ద్వారా, DI లోని విలువ అంకెల్లో దాని సంబంధిత అంకెల అక్షరాన్ని ఎంచుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"We are using the value in DI to look up its equivalent hexadecimal digit character in the lookup table Digits.","translation":"లుకప్ టేబుల్ అంకెల్లో దాని సమానమైన హెక్సాడెసిమల్ అంకెల అక్షరాన్ని చూడటానికి మేము DI లోని విలువను ఉపయోగిస్తున్నాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"See Figure 10.4.","translation":"చిత్రం 10.4 చూడండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"So far, we've read a character from the lookup table into AH.","translation":"ఇప్పటివరకు, మేము లుకప్ టేబుల్ నుండి ఒక అక్షరాన్ని AH లోకి చదివాము.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Now, we use yet another addressing mode to move the character from AX back into the second character of the destination string, whose address was passed to Byte2Str in DS:SI.","translation":"ఇప్పుడు, చిరునామా DS:SI లో Byte2Strకి పంపబడిన గమ్య స్థాన స్ట్రింగ్ యొక్క రెండవ అక్షరంలోకి AX నుండి అక్షరాన్ని తరలించడానికి మేము మరొక అడ్రసింగ్ మోడ్ను ఉపయోగిస్తాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This addressing mode is called indirect displacement addressing, though I question the wisdom of memorizing that term.","translation":"ఈ అడ్రసింగ్ మోడ్ను పరోక్ష స్థానభ్రంశం అడ్రసింగ్ అంటారు, అయితే ఆ పదాన్ని గుర్తుంచుకోవడం యొక్క జ్ఞానాన్ని నేను ప్రశ్నిస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The mode is nothing more than indirect addressing (that is, addressing the contents of memory at [SI]) with the addition of a literal displacement.","translation":"ఈ మోడ్ పరోక్ష అడ్రసింగ్ కంటే ఎక్కువ కాదు (అంటే, [SI] వద్ద మెమరీలోని విషయాలను పరిష్కరించడం) అక్షర స్థానభ్రంశం యొక్క చేరికతో.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Once this MOV is done, the first of the two nybbles passed to Byte2Str in AL has been converted to its character equivalent and stored in the destination string variable at DS:SI.","translation":"ఈ MOV పూర్తయిన తర్వాత, AL లో Byte2Strకి పంపబడిన రెండు నైబుల్స్లో మొదటిది దాని అక్షర సమానంగా మార్చబడి DS:SI వద్ద గమ్య స్థాన స్ట్రింగ్ వేరియబుల్లో నిల్వ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Now we have to do it again, this time for the high nybble.","translation":"ఇప్పుడు మనం దీన్ని మళ్ళీ చేయాలి, ఈసారి అధిక నైబుల్ కోసం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Shifting the High Nybble into the Low Nybble","translation":"అధిక నైబుల్ను తక్కువ నైబుల్లోకి మార్చడం","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A feature without value in some applications, such as financial programming.","translation":"కొన్ని అనువర్తనాల్లో, ఆర్థిక ప్రోగ్రామింగ్ వంటి వాటిలో విలువ లేని లక్షణం ఇది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Here's how you use DOS interrupt 21H service 40H:","translation":"DOS అంతరాయం 21H సేవ 40Hని మీరు ఎలా ఉపయోగిస్తారంటే:","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You must pass the offset address of the string in DX, the length of the string in CX, and a file handle in BX.","translation":"మీరు DXలో స్ట్రింగ్ యొక్క ఆఫ్సెట్ చిరునామాను, CXలో స్ట్రింగ్ యొక్క పొడవును మరియు BXలో ఫైల్ హ్యాండిల్ను తప్పనిసరిగా పాస్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"I won't explain file handles in detail in this book, but any good DOS reference will be adequate in picking up the details.","translation":"నేను ఈ పుస్తకంలో ఫైల్ హ్యాండిల్స్ను వివరంగా వివరించను, కానీ ఏదైనా మంచి DOS సూచన వివరాలను తెలుసుకోవడానికి సరిపోతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"By passing the handle of a disk-based text file to DOS service 40H, you can write text to a disk-based text file instead of to the screen.","translation":"డిస్క్-ఆధారిత టెక్స్ట్ ఫైల్ యొక్క హ్యాండిల్ను DOS సేవ 40Hకి పంపడం ద్వారా, మీరు స్క్రీన్కు బదులుగా డిస్క్-ఆధారిత టెక్స్ట్ ఫైల్కు వచనాన్ని వ్రాయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"As given, Write uses standard file handle 1, which is standard output.","translation":"ఇచ్చిన విధంగా, రైట్ ప్రామాణిక ఫైల్ హ్యాండిల్ 1ని ఉపయోగిస్తుంది, ఇది ప్రామాణిక అవుట్పుట్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard output is by default directed to the screen display, but you can use various DOS commands to redirect standard output to other destinations, such as the printer or a disk file.","translation":"ప్రామాణిక అవుట్పుట్ డిఫాల్ట్గా స్క్రీన్ డిస్ప్లేకు నిర్దేశించబడుతుంది, కానీ మీరు ప్రింటర్ లేదా డిస్క్ ఫైల్ వంటి ఇతర గమ్యస్థానాలకు ప్రామాణిక అవుట్పుట్ను మళ్లించడానికి వివిధ DOS ఆదేశాలను ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Finally, here is the whole of the INFO. ASM program:","translation":"చివరగా, INFO. ASM ప్రోగ్రామ్ యొక్క మొత్తం ఇక్కడ ఉంది:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This program demonstrates how lookup tables and numerous instructions are used.","translation":"ఈ ప్రోగ్రామ్ లుకప్ టేబుల్స్ మరియు అనేక సూచనలను ఎలా ఉపయోగిస్తారో వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Here we display the name of the program and its author:","translation":"ఇక్కడ మేము ప్రోగ్రామ్ పేరు మరియు దాని రచయితను ప్రదర్శిస్తాము:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Here we display the name of the installed video board:","translation":"ఇక్కడ మేము ఇన్స్టాల్ చేయబడిన వీడియో బోర్డ్ పేరును ప్రదర్శిస్తాము:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Here we display the segment address of the refresh buffer:","translation":"ఇక్కడ మేము రిఫ్రెష్ బఫర్ యొక్క సెగ్మెంట్ చిరునామాను ప్రదర్శిస్తాము:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Here we display the size of the current text font:","translation":"ఇక్కడ మేము ప్రస్తుత టెక్స్ట్ ఫాంట్ పరిమాణాన్ని ప్రదర్శిస్తాము:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Here we display the number of lines on the screen:","translation":"ఇక్కడ మేము తెరపై ఉన్న లైన్ల సంఖ్యను ప్రదర్శిస్తాము:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Finally, we display the size of the video refresh buffer:","translation":"చివరగా, మేము వీడియో రిఫ్రెష్ బఫర్ పరిమాణాన్ని ప్రదర్శిస్తాము:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Assembly strings have no boundary values or length indicators.","translation":"అసెంబ్లీ స్ట్రింగ్లకు సరిహద్దు విలువలు లేదా పొడవు సూచికలు లేవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You should instead think of strings in much the same way you think of segments: in terms of the register values that define them.","translation":"మీరు సెగ్మెంట్ల గురించి ఆలోచించే విధంగానే స్ట్రింగ్ల గురించి ఆలోచించాలి: వాటిని నిర్వచించే రిజిస్టర్ విలువల పరంగా.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A source string is pointed to by DS:SI.","translation":"DS:SI ద్వారా సోర్స్ స్ట్రింగ్ సూచించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A destination string is pointed to by ES:DI.","translation":"ES:DI ద్వారా గమ్యస్థాన స్ట్రింగ్ సూచించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The length of both kinds of strings is the value you place in CX.","translation":"రెండు రకాల స్ట్రింగ్ల పొడవు మీరు CXలో ఉంచే విలువ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"DS and SI are not involved.","translation":"DS మరియు SI ఇందులో భాగం కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"ES must be loaded with the segment address of the destination string.","translation":"గమ్య స్ట్రింగ్ యొక్క సెగ్మెంట్ చిరునామాతో ES లోడ్ చేయబడాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"DI must be loaded with the offset address of the destination string.","translation":"గమ్య స్ట్రింగ్ యొక్క ఆఫ్సెట్ చిరునామాతో DI లోడ్ చేయబడాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Think: DI, the destination index.","translation":"ఆలోచించండి: DI, గమ్య సూచిక.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"CX (think: the Count register) must be loaded with the number of times the copy of AX is to be stored into the string.","translation":"CX (ఆలోచించండి: కౌంట్ రిజిస్టర్) AX యొక్క కాపీని స్ట్రింగ్లో ఎన్నిసార్లు నిల్వ చేయాలో ఆ సంఖ్యతో లోడ్ చేయబడాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"AX must be loaded with the word value to be stored into the string.","translation":"స్ట్రింగ్లో నిల్వ చేయవలసిన పద విలువతో AX లోడ్ చేయబడాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Executing the STOSW Instruction Once you set up these four registers, you can safely execute a STOSW instruction.","translation":"STOSW సూచనను అమలు చేయడం మీరు ఈ నాలుగు రిజిస్టర్లను సెటప్ చేసిన తర్వాత, మీరు సురక్షితంగా STOSW సూచనను అమలు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The word value in AX is copied to the word at ES:DI.","translation":"AX లోని పద విలువ ES:DI వద్ద ఉన్న పదానికి కాపీ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"DI is incremented by 2, such that ES:DI now points to the next word in memory following the one just written to.","translation":"DI 2 ద్వారా పెరుగుతుంది, తద్వారా ES:DI ఇప్పుడు మెమరీలోని తదుపరి పదానికి సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"One copy of AX gets copied to one word in memory.","translation":"AX యొక్క ఒక కాపీ మెమరీలోని ఒక పదానికి కాపీ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The DI register is adjusted so that it'll be ready for the next time STOSW is executed.","translation":"DI రిజిస్టర్ సర్దుబాటు చేయబడుతుంది, తద్వారా తదుపరిసారి STOSW అమలు చేయబడటానికి ఇది సిద్ధంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"CX is not decremented by STOSW.","translation":"CX STOSW ద్వారా తగ్గించబడదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"CX is decremented automatically only if you put the REP prefix in front of STOSW.","translation":"మీరు STOSW ముందు REP ఉపసర్గను ఉంచినప్పుడు మాత్రమే CX స్వయంచాలకంగా తగ్గుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Lacking the REP prefix, you have to do the decrementing yourself, either explicitly through DEC or through the LOOP instruction.","translation":"REP ఉపసర్గ లేకపోవడంతో, మీరు తగ్గించే పనిని మీరే చేయాలి, స్పష్టంగా DEC ద్వారా లేదా LOOP సూచన ద్వారా.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"You can change AX if you like, but the changed value will be copied into memory.","translation":"మీరు চাইলে AX ని మార్చవచ్చు, కానీ మార్చిన విలువ మెమరీలోకి కాపీ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"To make STOSW fully automatic, just hang the REP prefix ahead of it.","translation":"STOSW ని పూర్తిగా స్వయంచాలకంగా చేయడానికి, REP ఉపసర్గను దాని ముందు ఉంచండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"What REP does is beautifully simple: It sets up the tightest of all tight loops completely inside the CPU and fires copies of AX into memory repeatedly.","translation":"REP చేసేది చాలా సులభం: ఇది CPU లోపల అన్ని బిగుతైన లూప్లను ఏర్పాటు చేస్తుంది మరియు AX యొక్క కాపీలను పదేపదే మెమరీలోకి పంపుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Man, now that's programming!","translation":"అబ్బ, ఇప్పుడు అదే ప్రోగ్రామింగ్!","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The following macro sets up and triggers REP STOSW to clear the video refresh buffer.","translation":"వీడియో రిఫ్రెష్ బఫర్ను క్లియర్ చేయడానికి కింది స్థూలచిత్రం REP STOSW ని సెటప్ చేస్తుంది మరియు ట్రిగ్గర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A pointer is an address, quite simply.","translation":"ఒక పాయింటర్ అనేది ఒక చిరునామా, చాలా సులభంగా.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Each entry in the OriginTbl lookup table is two bytes in size.","translation":"OriginTbl లుకప్ పట్టికలోని ప్రతి ఎంట్రీ రెండు బైట్ల పరిమాణంలో ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When table elements are more than one byte long, you have to multiply the index by the number of bytes in each table element.","translation":"పట్టిక మూలకాలు ఒకటి కంటే ఎక్కువ బైట్ల పొడవు ఉన్నప్పుడు, మీరు సూచికను ప్రతి పట్టిక మూలకంలోని బైట్ల సంఖ్యతో గుణించాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Suppose you get a code 2 back from DispID, indicating that you have a CGA in the system.","translation":"మీరు DispID నుండి కోడ్ 2 ని తిరిగి పొందినట్లయితే, మీ సిస్టమ్లో CGA ఉందని ఇది సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Shifting a value to the left by one bit multiplies the overall value by 2.","translation":"ఒక బిట్ ద్వారా ఎడమవైపుకు విలువను మార్చడం మొత్తం విలువను 2తో గుణిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Shifting a value to the left by two bits multiplies the value by 4.","translation":"రెండు బిట్ల ద్వారా ఎడమవైపుకు విలువను మార్చడం విలువను 4తో గుణిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Shifting right by one bit divides by 2; shifting right by two bits divides by 4, and so on.","translation":"ఒక బిట్ ద్వారా కుడివైపుకు మార్చడం 2 ద్వారా విభజిస్తుంది; రెండు బిట్ల ద్వారా కుడివైపుకు మార్చడం 4 ద్వారా విభజిస్తుంది, మరియు ఇలాగే.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The advantage to multiplying with shift instructions is that it's fast.","translation":"షిఫ్ట్ సూచనలతో గుణించడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే ఇది వేగంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Even if it means leaving a little wasted space at the end of each element, do your best to make the length of your table elements equal to some power of two.","translation":"ప్రతి మూలకం చివరిలో కొంచెం వృధా స్థలం వదిలివేయవలసి వచ్చినా, మీ పట్టిక మూలకాల పొడవును రెండు యొక్క శక్తికి సమానంగా చేయడానికి ప్రయత్నించండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Sometimes tables can be as simple as those I've just shown you, which are simply sequences of single values.","translation":"కొన్నిసార్లు పట్టికలు నేను ఇప్పుడే చూపించినంత సరళంగా ఉండవచ్చు, ఇవి కేవలం ఒకే విలువల శ్రేణులు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Sometimes you'll need a table of tables, and (surprise!) the x86 instruction set contains some built-in machinery to handle such nested tables quickly and easily.","translation":"కొన్నిసార్లు మీకు పట్టికల పట్టిక అవసరం అవుతుంది, మరియు (ఆశ్చర్యం!) x86 సూచనల సమితి అటువంటి నెస్ట్ చేయబడిన పట్టికలను త్వరగా మరియు సులభంగా నిర్వహించడానికి కొన్ని అంతర్నిర్మిత యంత్రాలను కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This is good, but not enough: Each adapter has a name, a display buffer address, and a screen size dictated by the size of the current character font.","translation":"ఇది మంచిది, కానీ సరిపోదు: ప్రతి అడాప్టర్కు పేరు, డిస్ప్లే బఫర్ చిరునామా మరియు ప్రస్తుత అక్షర ఫాంట్ పరిమాణం ద్వారా నిర్దేశించబడిన స్క్రీన్ పరిమాణం ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"These items comprise a table of information about a display adapter, and if you wanted to put together a summary of all that information about all legal display adapters, you'd have to create such a table of tables.","translation":"ఈ అంశాలు డిస్ప్లే అడాప్టర్ గురించి సమాచారం యొక్క పట్టికను కలిగి ఉంటాయి మరియు మీరు చట్టబద్ధమైన అన్ని డిస్ప్లే అడాప్టర్ల గురించి ఆ సమాచారం మొత్తానికి సారాంశాన్ని రూపొందించాలనుకుంటే, మీరు అటువంటి పట్టికల పట్టికను సృష్టించాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The table consists of 12 subtables, one for each possible code returned by DispID as well as a subtable for several undefined codes.","translation":"పట్టిక 12 ఉప పట్టికలను కలిగి ఉంటుంది, DispID ద్వారా తిరిగి ఇవ్వబడిన ప్రతి కోడ్కు ఒకటి, అలాగే నిర్వచించబడని అనేక కోడ్ల కోసం ఒక ఉప పట్టిక.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Each subtable occupies three lines, for clarity's sake.","translation":"స్పష్టత కోసం ప్రతి ఉప పట్టిక మూడు లైన్లను ఆక్రమిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The first line is a 27-character quoted string containing the name of the display adapter.","translation":"మొదటి లైన్ 27-అక్షరాల కోట్ చేయబడిన స్ట్రింగ్, ఇందులో డిస్ప్లే అడాప్టర్ పేరు ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The second line is a word-sized address, the segment address of the visible display buffer corresponding to that name.","translation":"రెండవ లైన్ అనేది పద పరిమాణ చిరునామా, ఆ పేరుకు సంబంధించిన కనిపించే డిస్ప్లే బఫర్ యొక్క సెగ్మెంట్ చిరునామా.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The third line contains three numeric values.","translation":"మూడవ లైన్లో మూడు సంఖ్యా విలువలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When your assembly language programs begin executing, they should inspect such a table and extract the values pertinent to the currently installed display adapter.","translation":"మీ అసెంబ్లీ భాషా ప్రోగ్రామ్లు అమలు చేయడం ప్రారంభించినప్పుడు, అవి అటువంటి పట్టికను పరిశీలించాలి మరియు ప్రస్తుతం ఇన్స్టాల్ చేయబడిన డిస్ప్లే అడాప్టర్కు సంబంధించిన విలువలను సంగ్రహించాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"These extracted values should be ordinary variables in the data segment, easily accessible without further table searching.","translation":"ఈ సంగ్రహించిన విలువలు డేటా విభాగంలో సాధారణ వేరియబుల్స్ అయి ఉండాలి, తదుపరి పట్టిక శోధన లేకుండా సులభంగా యాక్సెస్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The first thing VidCheck does is call DispID to determine which display adapter is installed.","translation":"VidCheck చేసే మొదటి పని ఏమిటంటే, ఏ డిస్ప్లే అడాప్టర్ ఇన్స్టాల్ చేయబడిందో తెలుసుకోవడానికి DispIDని పిలవడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A numeric literal, when used in an assembly language instruction, is called immediate data.","translation":"అసెంబ్లీ భాషా సూచనలో ఉపయోగించినప్పుడు, సంఖ్యా అక్షరాలను తక్షణ డేటా అంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the macro is expanded, the argument you pass to the macro is substituted into the actual instruction.","translation":"స్థూల విస్తరణ జరిగినప్పుడు, మీరు స్థూలతకు పంపే వాదన వాస్తవ సూచనలోకి మార్చబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In other words, if you pass the value 10 in the %5 argument (ScreenY), the instruction MOV AL,%5 becomes MOV AL,10.","translation":"అంటే, మీరు %5 వాదన (స్క్రీన్Y)లో 10 విలువను పాస్ చేస్తే, MOV AL,%5 సూచన MOV AL,10 అవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"But if you pass the literal value 80 in the %3 argument (ScreenW), you cannot use IMUL %3.","translation":"కానీ మీరు %3 వాదన (స్క్రీన్W)లో 80 అనే అక్షర విలువను పాస్ చేస్తే, మీరు IMUL %3ని ఉపయోగించలేరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The problem is not that you're using macro arguments with IMUL.","translation":"సమస్య ఏమిటంటే మీరు IMULతో స్థూల వాదనలను ఉపయోగిస్తున్నారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The problem is that you're passing a numeric literal in a macro argument to an instruction that cannot accept immediate data.","translation":"సమస్య ఏమిటంటే మీరు తక్షణ డేటాను అంగీకరించలేని సూచనకు స్థూల వాదనలో సంఖ్యా అక్షరాన్ని పంపుతున్నారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Using literals saves memory by making memory variables unnecessary.","translation":"అక్షరాలను ఉపయోగించడం వలన మెమరీ వేరియబుల్స్ అవసరం లేకుండా మెమరీని ఆదా చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The SHOWCHAR.ASM routine defines a ScreenWidth value as an equate.","translation":"SHOWCHAR.ASM విధానం స్క్రీన్విడ్త్ విలువను సమానంగా నిర్వచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Adding ASCII Digits Once the correct offset into the buffer for the ruler's beginning is calculated in DI.","translation":"ASCII అంకెలను జోడించడం, రూలర్ ప్రారంభం కోసం బఫర్లోకి సరైన ఆఫ్సెట్ DIలో లెక్కించబడిన తర్వాత.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Note that the instruction MOV AL,'1' does not move the numeric value 01 into AL!","translation":"MOV AL,'1' సూచన సంఖ్యా విలువ 01ని ALలోకి తరలించదని గమనించండి!","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The '1' is an ASCII character, and the character '1' (the \"one\" digit) has a numeric value of 31H, or 49 decimal.","translation":"'1' అనేది ASCII అక్షరం, మరియు '1' అక్షరం (","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"After digit '1,' we need to display digit '2,' and to do that we need to change the value stored in AL from '1' to '2.'","translation":"'1' అంకె తర్వాత, మనం '2' అంకెను ప్రదర్శించాలి, మరియు అలా చేయడానికి మనం ALలో నిల్వ చేసిన విలువను '1' నుండి '2'కి మార్చాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Ordinarily, you can't just add '1' to '1' and get '2'.","translation":"సాధారణంగా, మీరు '1'కి '1'ని జోడించి '2' పొందలేరు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"However, in this case the x86 instruction set comes to the rescue, in the form of a somewhat peculiar instruction called AAA.","translation":"అయితే, ఈ సందర్భంలో x86 సూచన సెట్ AAA అని పిలువబడే కొంత ప్రత్యేకమైన సూచన రూపంలో రక్షించడానికి వస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"What AAA does is allow us, in fact, to add ASCII character digits rather than numeric values.","translation":"AAA ఏమి చేస్తుందంటే, వాస్తవానికి, సంఖ్యా విలువల కంటే ASCII అక్షర అంకెలను జోడించడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"AAA is one of a group of instructions called the BCD instructions.","translation":"AAA అనేది BCD సూచనలు అని పిలువబడే సూచనల సమూహంలో ఒకటి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A BCD value is a 4-bit value, occupying the low nybble of a byte.","translation":"BCD విలువ అనేది 4-బిట్ విలువ, ఇది ఒక బైట్ యొక్క తక్కువ నైబుల్ను ఆక్రమిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"So, if there were a way to perform BCD addition on the 86-family CPUs, adding '1' and '1' would indeed give us '2'.","translation":"కాబట్టి, 86-కుటుంబ CPUలలో BCD సంకలనాన్ని నిర్వహించడానికి ఒక మార్గం ఉంటే, '1' మరియు '1'ని జోడించడం నిజంగా మనకు '2' ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"AAA (and several other instructions I don't have room to discuss here) gives us that ability to perform BCD math.","translation":"AAA (మరియు నేను ఇక్కడ చర్చించడానికి స్థలం లేని అనేక ఇతర సూచనలు) BCD గణితాన్ని నిర్వహించడానికి మాకు ఆ సామర్థ్యాన్ని ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The actual technique may seem a little odd, but it does work.","translation":"నిజమైన సాంకేతికత కొంచెం విచిత్రంగా అనిపించవచ్చు, కానీ ఇది పని చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The STOSW instruction is used to send the value in AX to the memory location at ES:DI.","translation":"STOSW సూచన ES:DI వద్ద ఉన్న మెమరీ స్థానానికి AX లోని విలువను పంపడానికి ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If AL contains the value for the character A (65), incrementing AL changes the A character to a B (66).","translation":"AL అక్షరం A (65) విలువను కలిగి ఉంటే, ALని పెంచడం వలన A అక్షరం B (66)గా మారుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The AH half of AX contains the attribute byte, and we do not want to change that.","translation":"AX యొక్క AH సగం లక్షణాల బైట్ను కలిగి ఉంటుంది మరియు మేము దానిని మార్చకూడదనుకుంటున్నాము.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"BL is acting as a counter that governs the length of the lines of characters shown on the screen.","translation":"BL స్క్రీన్ మీద చూపబడే అక్షరాల పంక్తుల పొడవును నియంత్రించే కౌంటర్గా పనిచేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"LOOPNZ watches both the state of the CX register and the state of the Zero flag ZF.","translation":"LOOPNZ CX రిజిస్టర్ స్థితిని మరియు జీరో ఫ్లాగ్ ZF స్థితి రెండింటినీ గమనిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The inner loop is considered complete when we've displayed one full line of the ASCII table to the screen.","translation":"ASCII పట్టిక యొక్క ఒక పూర్తి లైన్ను స్క్రీన్కు ప్రదర్శించినప్పుడు అంతర్గత లూప్ పూర్తయినట్లు పరిగణించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"We modify DI to jump from the end of a completed line to the start of the next line at the left margin.","translation":"పూర్తయిన లైన్ ముగింపు నుండి ఎడమ మార్జిన్లో తదుపరి లైన్ ప్రారంభానికి వెళ్లడానికి మేము DIని సవరిస్తాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The outer loop shoots lines of characters at the screen, by repeating the inner loop some number of times.","translation":"బాహ్య లూప్ కొన్నిసార్లు అంతర్గత లూప్ను పునరావృతం చేయడం ద్వారా స్క్రీన్ వద్ద అక్షరాల పంక్తులను ప్రసారం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"SHOWCHAR.ASM contains two nested loops.","translation":"SHOWCHAR.ASM రెండు నెస్టెడ్ లూప్లను కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In particular, the MOVSW instruction is useful, because it allows you to copy entire regions of memory from one place to another.","translation":"ముఖ్యంగా, MOVSW సూచన ఉపయోగకరంగా ఉంటుంది, ఎందుకంటే ఇది మెమరీ యొక్క మొత్తం ప్రాంతాలను ఒక స్థలం నుండి మరొకదానికి కాపీ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Fast video is essential, and BIOS-based video generally fails in that regard-especially on older and slower machines.","translation":"వేగవంతమైన వీడియో అవసరం, మరియు BIOS ఆధారిత వీడియో సాధారణంగా ఆ విషయంలో విఫలమవుతుంది - ముఖ్యంగా పాత మరియు నెమ్మదిగా నడిచే కంప్యూటర్లలో.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You have the fundamentals of a really good and extremely fast toolkit of video routines for your assembly language programs.","translation":"మీ అసెంబ్లీ భాషా ప్రోగ్రామ్ల కోసం మీరు నిజంగా మంచి మరియు చాలా వేగవంతమైన వీడియో రొటీన్ల సాధనాల యొక్క మూలాలను కలిగి ఉన్నారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"WriteFast. A routine to move a string of characters from your data segment to the visible display buffer.","translation":"WriteFast. మీ డేటా విభాగం నుండి కనిపించే డిస్ప్లే బఫర్కు అక్షరాల స్ట్రింగ్ను తరలించడానికి ఒక సాధారణ పద్ధతి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Getting your video tools in order will allow you to move on to other, more involved subjects such as file I/O and interface to the serial and parallel ports.","translation":"మీ వీడియో సాధనాలను క్రమబద్ధీకరించడం వలన మీరు ఫైల్ I/O మరియు సీరియల్ మరియు సమాంతర పోర్ట్లకు ఇంటర్ఫేస్ వంటి ఇతర, మరింత సంబంధిత విషయాలకు వెళ్లడానికి వీలు కల్పిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"DOS is simple, forgiving, and present in nearly all Windows machines either as a lurker-beneath- the-windows (for Windows 9x) or a very high quality emulation (Windows NT).","translation":"DOS సరళమైనది, క్షమించేది మరియు దాదాపు అన్ని విండోస్ మెషీన్లలో విండోస్ కింద దాగి ఉన్నదిగా (విండోస్ 9x కోసం) లేదా చాలా అధిక-నాణ్యత ఎమ్యులేషన్ (విండోస్ NT)గా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The relationship between Windows and its applications is much closer and far more complex.","translation":"విండోస్ మరియు దాని అప్లికేషన్ల మధ్య సంబంధం చాలా దగ్గరగా మరియు చాలా సంక్లిష్టంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Just understanding how Windows and Windows applications work at the assembly level could take you months of study.","translation":"అసెంబ్లీ స్థాయిలో విండోస్ మరియు విండోస్ అప్లికేషన్లు ఎలా పని చేస్తాయో అర్థం చేసుకోవడానికి మీకు నెలల తరబడి అధ్యయనం పట్టవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Coding a sizeable app could take a year.","translation":"ఒక పెద్ద యాప్ను కోడింగ్ చేయడానికి ఒక సంవత్సరం పట్టవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In Linux, text mode is still mainstream.","translation":"Linuxలో, టెక్స్ట్ మోడ్ ఇప్పటికీ ప్రధాన స్రవంతిలో ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Learn Linux.","translation":"Linux నేర్చుకోండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"EMACS is way more than just an editor.","translation":"EMACS కేవలం ఒక ఎడిటర్ కంటే చాలా ఎక్కువ.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It's much closer to the integrated text-mode environments used in the last days of DOS.","translation":"ఇది DOS చివరి రోజుల్లో ఉపయోగించిన ఇంటిగ్రేటెడ్ టెక్స్ట్-మోడ్ పరిసరాలకు చాలా దగ్గరగా ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"EMACS can build an executable from inside the editor.","translation":"EMACS ఎడిటర్ లోపల నుండే ఎగ్జిక్యూటబుల్ ను నిర్మించగలదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Whole books have been written on EMACS.","translation":"EMACS గురించి పుస్తకాలు చాలా రాయబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If you intend to stick with Linux and do any significant programming for it, EMACS is indispensable.","translation":"మీరు Linux తో కొనసాగాలని మరియు దాని కోసం ఏదైనా ముఖ్యమైన ప్రోగ్రామింగ్ చేయాలని అనుకుంటే, EMACS అనివార్యం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Learn as much of it as you can.","translation":"మీరు వీలైనంత వరకు నేర్చుకోండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Linux (as a genuine implementation of Unix) is inescapably a C world.","translation":"Linux (Unix యొక్క నిజమైన అమలుగా) తప్పనిసరిగా C ప్రపంచం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Most of Linux is written in C, and what little isn't in C is in assembly.","translation":"Linux లో ఎక్కువ భాగం C లో వ్రాయబడింది, మరియు C లో లేనిది అసెంబ్లీలో ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"So, before you attempt your first assembly program, buy a book and get down and hack some C.","translation":"కాబట్టి, మీ మొదటి అసెంబ్లీ ప్రోగ్రామ్ను ప్రయత్నించే ముందు, ఒక పుస్తకం కొని, దిగి కొన్ని C ని హ్యాక్ చేయండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You don't need to do a lot of it, but make sure you understand all the basic C concepts, especially as they apply to function calls.","translation":"మీరు చాలా చేయనవసరం లేదు, కానీ మీరు అన్ని ప్రాథమిక C భావనలను, ముఖ్యంగా ఫంక్షన్ కాల్స్కు వర్తించే వాటిని అర్థం చేసుకున్నారని నిర్ధారించుకోండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"There are some excellent Pascal implementations for Linux, most of them free, so if you don't stick with assembly you have some alternatives to C.","translation":"Linux కోసం కొన్ని అద్భుతమైన పాస్కల్ అమలులు ఉన్నాయి, వాటిలో చాలా వరకు ఉచితం, కాబట్టి మీరు అసెంబ్లీతో ఉండకపోతే, మీకు C కి కొన్ని ప్రత్యామ్నాయాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"My choice is FreePascal 32.","translation":"నా ఎంపిక FreePascal 32.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"NASM for Linux Another (minor) reason that I chose NASM as the focus assembler for this book is that a very good implementation-still free-exists for Linux.","translation":"Linux కోసం NASM ఈ పుస్తకం కోసం నేను NASM ని ప్రధాన అసెంబ్లర్గా ఎంచుకోవడానికి మరొక (చిన్న) కారణం ఏమిటంటే, Linux కోసం చాలా మంచి అమలు-ఇప్పటికీ ఉచితం-ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"You can download NASM in either source code form or in assembled binary form, as an RPM (Red Hat Package Manager) archive.","translation":"మీరు NASM ని సోర్స్ కోడ్ రూపంలో లేదా అసెంబ్లీ చేయబడిన బైనరీ రూపంలో, RPM (రెడ్ హాట్ ప్యాకేజీ మేనేజర్) ఆర్కైవ్గా డౌన్లోడ్ చేసుకోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Installing the RPM file might seem to be easier, but there's a catch.","translation":"RPM ఫైల్ను ఇన్స్టాల్ చేయడం సులభంగా అనిపించవచ్చు, కానీ ఒక చిక్కు ఉంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Installing NASM's Source Code Don't faint, newcomers.","translation":"NASM యొక్క సోర్స్ కోడ్ను ఇన్స్టాల్ చేస్తోంది, కొత్తవారు స్పృహ తప్పకండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It's not that hard, and rebuilding tools is a fact of Linux life.","translation":"ఇది అంత కష్టం కాదు, మరియు సాధనాలను తిరిగి నిర్మించడం Linux జీవితంలో ఒక వాస్తవం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The tar utility is one of my least-favorite Unix utilities, because it has a whole different mindset for dealing with command-line parameters.","translation":"టార్ యుటిలిటీ నా అత్యంత ఇష్టపడని Unix యుటిలిటీలలో ఒకటి, ఎందుకంటే ఇది కమాండ్-లైన్ పారామితులతో వ్యవహరించడానికి పూర్తిగా భిన్నమైన మనస్తత్వాన్ని కలిగి ఉంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Once you get tar to extract all the files from the archive, you'll notice that tar has created a new directory on your hard drive.","translation":"మీరు ఆర్కైవ్ నుండి అన్ని ఫైల్లను సంగ్రహించడానికి టార్ని పొందిన తర్వాత, టార్ మీ హార్డ్ డ్రైవ్లో కొత్త డైరెక్టరీని సృష్టించిందని మీరు గమనించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The make utility is a puppet master that executes other programs according to a master plan, which is a simple text file called a make file.","translation":"మేక్ యుటిలిటీ అనేది ఒక మాస్టర్ ప్లాన్ ప్రకారం ఇతర ప్రోగ్రామ్లను అమలు చేసే ఒక కీలుబొమ్మ మాస్టర్, ఇది మేక్ఫైల్ అని పిలువబడే ఒక సాధారణ టెక్స్ట్ ఫైల్.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A C compiler is required to link an assembly program.","translation":"అసెంబ్లీ ప్రోగ్రామ్ను లింక్ చేయడానికి సి కంపైలర్ అవసరం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The executable file depends on one object code file.","translation":"ఎగ్జిక్యూటబుల్ ఫైల్ ఒక ఆబ్జెక్ట్ కోడ్ ఫైల్పై ఆధారపడి ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This line tells us what files are required, but not what must be done with them.","translation":"ఏ ఫైల్లు అవసరమో ఈ లైన్ చెబుతుంది, కానీ వాటితో ఏమి చేయాలో కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The second line tells us how the job is to be done.","translation":"రెండవ లైన్ పని ఎలా చేయాలో చెబుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The make mechanism has one more very important aspect: knowing whether the job as a whole actually has to be done at all.","translation":"మేక్ మెకానిజంకి మరొక ముఖ్యమైన అంశం ఉంది: మొత్తం పనిని నిజంగా చేయాలా లేదా అని తెలుసుకోవడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When a File Is Up to Date It may seem idiotic to have to come out and say so, but once a file has been compiled or linked, it's been done, and it doesn't have to be done again.","translation":"ఒక ఫైల్ అప్డేట్ అయినప్పుడు, అలా చెప్పడం తెలివితక్కువగా అనిపించవచ్చు, కానీ ఒకసారి ఫైల్ కంపైల్ చేయబడినా లేదా లింక్ చేయబడినా, అది పూర్తవుతుంది మరియు మళ్లీ చేయవలసిన అవసరం లేదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The make utility knows this.","translation":"మేక్ యుటిలిటీకి ఇది తెలుసు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It can tell when a compile or a link task needs to be done at all, and if the job doesn't have to be done, make will refuse to do it.","translation":"కంపైల్ లేదా లింక్ టాస్క్ ఎప్పుడు చేయాల్సిన అవసరం ఉందో ఇది చెప్పగలదు మరియు పని చేయనవసరం లేకపోతే, మేక్ దానిని చేయడానికి నిరాకరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Make looks at this and understands that the executable file eatlinux depends on the object code file eatlinux.o, and that you can't generate eatlinux without having eatlinux.o.","translation":"మేక్ దీన్ని చూస్తుంది మరియు ఎగ్జిక్యూటబుల్ ఫైల్ eatlinux, ఆబ్జెక్ట్ కోడ్ ఫైల్ eatlinux.o పై ఆధారపడి ఉందని మరియు eatlinux.o లేకుండా మీరు eatlinux ని రూపొందించలేరని అర్థం చేసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The make utility pays close attention to Linux timestamps.","translation":"మేక్ యుటిలిటీ లైనక్స్ టైమ్స్టాంప్లపై నిశితంగా దృష్టి పెడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Whenever you edit a source code file, or generate an object code file or an executable file, Linux updates that file's timestamp to the moment that the changes were finally completed.","translation":"మీరు సోర్స్ కోడ్ ఫైల్ను ఎడిట్ చేసినప్పుడల్లా లేదా ఆబ్జెక్ట్ కోడ్ ఫైల్ లేదా ఎగ్జిక్యూటబుల్ ఫైల్ను రూపొందించినప్పుడల్లా, మార్పులు పూర్తయిన క్షణానికి లైనక్స్ ఆ ఫైల్ యొక్క టైమ్స్టాంప్ను అప్డేట్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When a file is newer than all of the files that it depends upon, that file is said to be up to date.","translation":"ఒక ఫైల్ అది ఆధారపడే అన్ని ఫైల్ల కంటే కొత్తగా ఉన్నప్పుడు, ఆ ఫైల్ అప్డేట్ చేయబడిందని చెప్పబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"But the real value in the make mechanism begins to appear when a single make file contains chains of dependencies.","translation":"కానీ ఒకే మేక్ ఫైల్ డిపెండెన్సీల గొలుసులను కలిగి ఉన్నప్పుడు మేక్ మెకానిజంలో అసలైన విలువ కనిపించడం ప్రారంభమవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Even in the simplest make files, there will be dependencies that depend on other dependencies.","translation":"అతి సాధారణమైన మేక్ ఫైల్లలో కూడా, ఇతర డిపెండెన్సీలపై ఆధారపడే డిపెండెన్సీలు ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The gist here is that to make eatlinux, you start with eatlinux.o and process it according to the recipe in the second line.","translation":"ఇక్కడ సారాంశం ఏమిటంటే, eatlinuxని తయారు చేయడానికి, మీరు eatlinux.oతో ప్రారంభించి, రెండవ లైన్లో ఉన్న రెసిపీ ప్రకారం ప్రాసెస్ చేస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Assembling eatlinux.asm pretty much requires that we link eatlinux.o to create eatlinux.","translation":"eatlinux.asmని అసెంబ్లింగ్ చేయడానికి eatlinuxని సృష్టించడానికి eatlinux.oని లింక్ చేయడం దాదాపు అవసరం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"But consider a real-world programming project, in which there are hundreds of separate source code files.","translation":"కానీ వాస్తవ ప్రపంచ ప్రోగ్రామింగ్ ప్రాజెక్ట్ను పరిగణించండి, దీనిలో వందలాది వేర్వేరు సోర్స్ కోడ్ ఫైల్లు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The make utility makes remembering any of this unnecessary.","translation":"మేక్ యుటిలిటీ వీటిలో దేనినైనా గుర్తుంచుకోవడం అనవసరం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Make figures it out and does only what must be done, no more, no less.","translation":"మేక్ దానిని గుర్తిస్తుంది మరియు ఏమి చేయాలో మాత్రమే చేస్తుంది, ఎక్కువ కాదు, తక్కువ కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Make ensures that all work that needs to be done gets done.","translation":"చేయవలసిన మొత్తం పని పూర్తయ్యేలా మేక్ చూస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In place of square brackets, AT&T uses parentheses to enclose the components of a memory address.","translation":"చతురస్రాకార బ్రాకెట్లకు బదులుగా, AT&T మెమరీ చిరునామా యొక్క భాగాలను చేర్చడానికి బ్రాకెట్లను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Here, we're moving the byte quantity at [ebx] to AL.","translation":"ఇక్కడ, మేము [ebx] వద్ద ఉన్న బైట్ పరిమాణాన్ని ALకి తరలిస్తున్నాము.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Don't forget that the order of operands is reversed from what Intel syntax does!","translation":"ఆపరేండ్ల క్రమం ఇంటెల్ సింటాక్స్ చేసే దానికంటే భిన్నంగా ఉంటుందని గుర్తుంచుకోండి!","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Inside the parentheses you place the base, the index, and the scale, when present.","translation":"బ్రాకెట్ల లోపల మీరు బేస్, సూచిక మరియు స్కేల్ను ఉంచుతారు, ఉన్నప్పుడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The displacement, when one exists, must go in front of and outside the parentheses.","translation":"ఒకటి ఉన్నప్పుడు, స్థానభ్రంశం బ్రాకెట్ల ముందు మరియు వెలుపల ఉండాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Note that in AT&T syntax, you don't do the math inside the parentheses.","translation":"AT&T సింటాక్స్లో, మీరు బ్రాకెట్ల లోపల గణితం చేయకూడదని గమనించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The base, index, and scale are separated by commas, and plus signs and asterisks are not allowed.","translation":"బేస్, ఇండెక్స్ మరియు స్కేల్ కామాలతో వేరు చేయబడతాయి మరియు ప్లస్ గుర్తులు మరియు నక్షత్రాలు అనుమతించబడవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The displacement value is optional.","translation":"స్థానభ్రంశం విలువ ఐచ్ఛికం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You may omit it entirely if there's no displacement in the memory reference.","translation":"మెమరీ సూచనలో స్థానభ్రంశం లేకపోతే మీరు దీన్ని పూర్తిగా వదిలివేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Similarly, you may omit the scale if there is no scale value present in the effective address.","translation":"అదేవిధంగా, ప్రభావవంతమైన చిరునామాలో స్కేల్ విలువ లేకపోతే మీరు స్కేల్ను వదిలివేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"What you will see most of the time, however, is a very simple type of memory reference: −16(%ebp)","translation":"అయితే, మీరు చాలాసార్లు చూసేది చాలా సాధారణ రకం మెమరీ సూచన: −16(%ebp)","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The displacements will vary, of course, but what this almost always means is that an instruction is referencing a data item somewhere on the stack.","translation":"స్థానభ్రంశాలు, వాస్తవానికి, మారుతూ ఉంటాయి, కానీ దీని అర్థం దాదాపు ఎల్లప్పుడూ ఒక సూచన స్టాక్లో ఎక్కడో ఒక డేటా అంశాన్ని సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"C code allocates its variables on the stack, in a stack frame, and then references those variables by constant offsets from the value in EBP.","translation":"C కోడ్ దాని వేరియబుల్స్ను స్టాక్లో, స్టాక్ ఫ్రేమ్లో కేటాయిస్తుంది, ఆపై EBPలోని విలువ నుండి స్థిరమైన ఆఫ్సెట్ల ద్వారా ఆ వేరియబుల్స్ను సూచిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"EBP acts as a \"thumb in the stack,\" and items on the stack may be referenced in terms of offsets (either positive or negative) away from EBP.","translation":"EBP ఒక \"స్టాక్లో బొటనవేలు\" వలె పనిచేస్తుంది మరియు స్టాక్లోని అంశాలను EBP నుండి దూరంగా (పాజిటివ్ లేదా నెగటివ్) ఆఫ్సెట్ల పరంగా సూచించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The preceding reference would tell a machine instruction to work with an item at the address in EBP minus 16 bytes.","translation":"మునుపటి సూచన మెషిన్ సూచనకు EBPలో చిరునామా వద్ద ఉన్న అంశంతో 16 బైట్లను తీసివేయమని చెబుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"I have a lot more to say about stack frames in the next chapter.","translation":"తదుపరి అధ్యాయంలో స్టాక్ ఫ్రేమ్ల గురించి నేను ఇంకా చాలా చెప్పాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The first thing you have to understand about the GNU debugger gdb is that it was designed to work as a high-level debugger on C programs.","translation":"GNU డీబగ్గర్ gdb గురించి మీరు అర్థం చేసుకోవలసిన మొదటి విషయం ఏమిటంటే, ఇది C ప్రోగ్రామ్లపై హై-లెవెల్ డీబగ్గర్గా పనిచేయడానికి రూపొందించబడింది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"That is, gdb allows programmers to single-step a C program by stepping from one C statement to another, setting breakpoints on C statements, and so on.","translation":"అంటే, gdb ప్రోగ్రామర్లు ఒక C స్టేట్మెంట్ నుండి మరొక C స్టేట్మెంట్కు వెళ్లడం ద్వారా, C స్టేట్మెంట్లపై బ్రేక్పాయింట్లను సెట్ చేయడం ద్వారా మరియు మొదలైన వాటి ద్వారా C ప్రోగ్రామ్ను సింగిల్-స్టెప్ చేయడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It isn't nearly as good as DOS DEBUG at poking around assembly code programs, or any programs at the binary level irrespective of their source language.","translation":"అసెంబ్లీ కోడ్ ప్రోగ్రామ్లను లేదా వాటి సోర్స్ భాషతో సంబంధం లేకుండా బైనరీ స్థాయిలో ఏదైనా ప్రోగ్రామ్లను పరిశీలించడంలో DOS DEBUG అంత మంచిది కాదు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If you're going to use a debugger to work on your assembly code, gdb will have to do.","translation":"మీరు మీ అసెంబ్లీ కోడ్పై పని చేయడానికి డీబగ్గర్ని ఉపయోగిస్తుంటే, gdb తప్పనిసరిగా చేయాలి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The print command will display the value stored in any of the general-purpose registers.","translation":"ప్రింట్ కమాండ్ ఏదైనా సాధారణ-ప్రయోజన రిజిస్టర్లలో నిల్వ చేయబడిన విలువను ప్రదర్శిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The only trick is to prefix the name of the register with a dollar sign:","translation":"ఏకైక ట్రిక్ ఏమిటంటే రిజిస్టర్ పేరుకు డాలర్ గుర్తును చేర్చడం:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Unless you apply a format code (more on which follows), the default display of register values will be in decimal.","translation":"మీరు ఫార్మాట్ కోడ్ను వర్తింపజేయకపోతే (దీని గురించి మరింత తెలుసుకోవచ్చు), రిజిస్టర్ విలువల డిఫాల్ట్ డిస్ప్లే దశాంశంలో ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The value history is a memory-based table in which gdb keeps values displayed using the print command.","translation":"విలువ చరిత్ర అనేది మెమరీ-ఆధారిత పట్టిక, దీనిలో gdb ప్రింట్ కమాండ్ ఉపయోగించి ప్రదర్శించబడే విలువలను ఉంచుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Each time you display something using print, gdb tucks the displayed value away in the value history and gives it an identification number, starting with 1.","translation":"మీరు ప్రింట్ ఉపయోగించి ఏదైనా ప్రదర్శించిన ప్రతిసారీ, gdb ప్రదర్శించబడిన విలువను విలువ చరిత్రలో ఉంచుతుంది మరియు దానికి 1తో ప్రారంభమయ్యే గుర్తింపు సంఖ్యను ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"You can then redisplay the value by executing the print command on the value history identification number:","translation":"అప్పుడు మీరు విలువ చరిత్ర గుర్తింపు సంఖ్యపై ప్రింట్ కమాండ్ అమలు చేయడం ద్వారా విలువను మళ్లీ ప్రదర్శించవచ్చు:","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One important caution is that gdb cannot display values for 8-bit or 16-bit registers.","translation":"ఒక ముఖ్యమైన హెచ్చరిక ఏమిటంటే gdb 8-బిట్ లేదా 16-బిట్ రిజిస్టర్ల కోసం విలువలను ప్రదర్శించలేకపోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The print command is the best way to display values of program variables other than ASCII strings or other arrays.","translation":"ASCII స్ట్రింగ్లు లేదా ఇతర శ్రేణులు కాకుండా ప్రోగ్రామ్ వేరియబుల్స్ విలువలను ప్రదర్శించడానికి ప్రింట్ కమాండ్ ఉత్తమ మార్గం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can specify how the variable will be displayed (and this applies to registers as well) with a format code.","translation":"వేరియబుల్ ఎలా ప్రదర్శించబడుతుందో మీరు పేర్కొనవచ్చు (మరియు ఇది రిజిస్టర్లకు కూడా వర్తిస్తుంది) ఫార్మాట్ కోడ్తో.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The format code allows you to display registers or variables in decimal, octal, binary, or hex, or as ASCII characters.","translation":"ఫార్మాట్ కోడ్ రిజిస్టర్లు లేదా వేరియబుల్స్ను దశాంశ, అష్టాంశ, బైనరీ లేదా హెక్స్ రూపంలో లేదా ASCII అక్షరాలుగా ప్రదర్శించడానికి మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"You can display a register or a variable in binary by using the t format code.","translation":"t ఫార్మాట్ కోడ్ను ఉపయోగించి మీరు రిజిస్టర్ లేదా వేరియబుల్ను బైనరీలో ప్రదర్శించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This is useful when you're interpreting a register value as a bitmap or as a set of flags:","translation":"మీరు రిజిస్టర్ విలువను బిట్మ్యాప్గా లేదా ఫ్లాగ్ల సమితిగా అర్థం చేసుకున్నప్పుడు ఇది ఉపయోగపడుతుంది:","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Note that when using the t format code, leading zeros in the display are suppressed, so you will not always get 32 ones or zeros.","translation":"t ఫార్మాట్ కోడ్ను ఉపయోగిస్తున్నప్పుడు, ప్రదర్శనలో ముందున్న సున్నాలను అణిచివేస్తారు, కాబట్టి మీకు ఎల్లప్పుడూ 32 ఒకటి లేదా సున్నాలు లభించకపోవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Here, however, is a problem: The print command has no way to display anything that won't fit in a character or integer value, so strings can't be displayed that way.","translation":"అయితే, ఇక్కడ ఒక సమస్య ఉంది: ప్రింట్ కమాండ్ అక్షరం లేదా పూర్ణాంక విలువలో సరిపోని దేనినైనా ప్రదర్శించడానికి మార్గం లేదు, కాబట్టి స్ట్రింగ్లను ఆ విధంగా ప్రదర్శించలేరు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Instead, you must display null-terminated string variables with the x command (think \"examine\"), which is intended for use in examining memory.","translation":"బదులుగా, మీరు x కమాండ్ ( ","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Program variables exist in memory, and hence can be displayed with the x command.","translation":"ప్రోగ్రామ్ వేరియబుల్స్ మెమరీలో ఉంటాయి, అందువల్ల x కమాండ్తో ప్రదర్శించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Here's a typical use of the x command to display a string variable:","translation":"స్ట్రింగ్ వేరియబుల్ను ప్రదర్శించడానికి x కమాండ్ యొక్క సాధారణ ఉపయోగం ఇక్కడ ఉంది:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"As with the print command, the format codes are placed first, preceded by a slash symbol (/).","translation":"ప్రింట్ కమాండ్ లాగానే, ఫార్మాట్ కోడ్లను మొదట ఉంచుతారు, దీనికి ముందు స్లాష్ గుర్తు (/) ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"C programmers will recognize the use of the ampersand here: It's the \"address of\" operator in C.","translation":"సి ప్రోగ్రామర్లు ఇక్కడ & గుర్తును ఉపయోగిస్తారు: ఇది సి లోని ","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The x command can dump memory for a specified number of bytes beginning at a specified address.","translation":"x కమాండ్ పేర్కొన్న చిరునామాతో ప్రారంభమయ్యే నిర్దిష్ట సంఖ్యలో బైట్ల కోసం మెమరీని డంప్ చేయగలదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can edit source code files and make files.","translation":"మీరు సోర్స్ కోడ్ ఫైల్లను ఎడిట్ చేయవచ్చు మరియు ఫైల్లను తయారు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You can assemble files and link them to generate executable files.","translation":"మీరు ఫైల్లను అసెంబుల్ చేయవచ్చు మరియు వాటిని లింక్ చేసి ఎగ్జిక్యూటబుల్ ఫైల్లను ఉత్పత్తి చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can run the executable program files to test them.","translation":"మీరు వాటిని పరీక్షించడానికి ఎగ్జిక్యూటబుల్ ప్రోగ్రామ్ ఫైల్లను అమలు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You can invoke the GNU debugger.","translation":"మీరు GNU డీబగ్గర్ను పిలవవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You can execute nearly any Unix command that can be issued from inside a Unix shell such as bash.","translation":"మీరు బాష్ వంటి యూనిక్స్ షెల్ లోపల నుండి జారీ చేయగల దాదాపు ఏదైనా యూనిక్స్ ఆదేశాన్ని అమలు చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Why waste time ducking in and out of EMACS as though it were nothing more than a text editor?","translation":"కేవలం టెక్స్ట్ ఎడిటర్ కంటే ఎక్కువ ఏమీ లేనట్లుగా EMACS లోపలికి మరియు బయటకు వెళ్లడం ద్వారా సమయాన్ని ఎందుకు వృధా చేయాలి?","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"More than one book has been written about EMACS.","translation":"EMACS గురించి ఒకటి కంటే ఎక్కువ పుస్తకాలు వ్రాయబడ్డాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"I recommend the book Learning GNU EMACS by Debra Cameron, Bill Rosenblatt, and Eric S. Raymond (O'Reilly, 1996).","translation":"నేను డెబ్రా కామెరాన్, బిల్ రోసెన్బ్లాట్ మరియు ఎరిక్ ఎస్. రేమండ్ (ఓ'రైలీ, 1996) రచించిన లెర్నింగ్ GNU EMACS పుస్తకాన్ని సిఫార్సు చేస్తున్నాను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"My one gripe is that it doesn't cover the X Window version of EMACS specifically, but all the key commands are the same.","translation":"నా ఒక్క ఫిర్యాదు ఏమిటంటే, ఇది ప్రత్యేకంగా EMACS యొక్క X విండో వెర్షన్ను కవర్ చేయదు, కానీ అన్ని కీ ఆదేశాలు ఒకే విధంగా ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The important big-picture thing to understand about EMACS is that it is buffer-based.","translation":"EMACS గురించి అర్థం చేసుకోవలసిన ముఖ్యమైన పెద్ద-చిత్రం విషయం ఏమిటంటే, ఇది బఫర్-ఆధారితమైనది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When you open a file, EMACS opens a buffer and loads text from the opened file into that buffer.","translation":"మీరు ఫైల్ను తెరిచినప్పుడు, EMACS ఒక బఫర్ను తెరుస్తుంది మరియు తెరిచిన ఫైల్ నుండి వచనాన్ని ఆ బఫర్లోకి లోడ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"You can also open a buffer as a scratch buffer, type something in it, cut or copy portions of that buffer into another buffer, and then just kill the scratch buffer (delete it) without saving it to disk.","translation":"మీరు ఒక బఫర్ను స్క్రాచ్ బఫర్గా కూడా తెరవవచ్చు, దానిలో ఏదైనా టైప్ చేయవచ్చు, ఆ బఫర్లోని భాగాలను కత్తిరించవచ్చు లేదా మరొక బఫర్లోకి కాపీ చేయవచ్చు, ఆపై దానిని డిస్క్కు సేవ్ చేయకుండానే స్క్రాచ్ బఫర్ను (తొలగించవచ్చు).","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When EMACS runs the make facility, it pipes output from make and from the tools that make invokes into a new buffer.","translation":"EMACS మేక్ సౌకర్యాన్ని అమలు చేసినప్పుడు, అది మేక్ నుండి మరియు మేక్ పిలిచే సాధనాల నుండి అవుట్పుట్ను కొత్త బఫర్లోకి పంపుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It does the same when you invoke the GNU debugger from inside EMACS: gdb's output is piped into a buffer, which you can save to disk if you choose for later reference.","translation":"మీరు EMACS లోపల నుండి GNU డీబగ్గర్ను పిలిచినప్పుడు ఇది అదే చేస్తుంది: gdb యొక్క అవుట్పుట్ ఒక బఫర్లోకి పంపబడుతుంది, మీరు తరువాత సూచన కోసం ఎంచుకుంటే, మీరు డిస్క్కు సేవ్ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Most usefully, you can invoke a Unix shell (I use bash) from inside EMACS, and EMACS will pipe its output into a new buffer, which like any buffer can be saved to disk.","translation":"అత్యంత ఉపయోగకరంగా, మీరు EMACS లోపల నుండి యూనిక్స్ షెల్ (నేను బాష్ ఉపయోగిస్తాను) ని పిలవవచ్చు మరియు EMACS దాని అవుట్పుట్ను కొత్త బఫర్లోకి పంపుతుంది, ఇది ఏదైనా బఫర్ లాగానే డిస్క్కు సేవ్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Especially while you're learning, there's very little that you'll need to do that can't be done either from the EMACS menus or from a shell opened from within EMACS.","translation":"ముఖ్యంగా మీరు నేర్చుకునేటప్పుడు, EMACS మెనూల నుండి లేదా EMACS లోపల నుండి తెరిచిన షెల్ నుండి చేయలేనిది మీరు చేయవలసినది చాలా తక్కువ.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Opening a Shell from inside EMACS This last is worth explaining, because it is less obvious than most of the editing commands.","translation":"EMACS లోపల నుండి షెల్ తెరవడం ఇది చివరిది వివరించదగినది, ఎందుకంటే ఇది చాలా ఎడిటింగ్ ఆదేశాల కంటే తక్కువ స్పష్టంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There is currently no EMACS menu item that opens a shell in a window.","translation":"ప్రస్తుతం విండోలో షెల్ను తెరిచే EMACS మెనూ అంశం లేదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"To open a shell, the command is \"Esc x shell.\"","translation":"షెల్ తెరవడానికి, ఆదేశం \"Esc x shell.\"","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You press the Esc key followed by the lowercase x key (don't press both at once!) and, in its command line at the bottom of its window, EMACS will display the unhelpful string \"M-x.\"","translation":"మీరు ఎస్కేప్ కీని నొక్కండి, ఆపై చిన్న అక్షరం x కీని నొక్కండి (రెండింటినీ ఒకేసారి నొక్కవద్దు!) మరియు, దాని విండో దిగువన ఉన్న దాని కమాండ్ లైన్లో, EMACS సహాయం లేని స్ట్రింగ్ \"M-x.\"ని ప్రదర్శిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"They send it to a special Unix mechanism called standard output, which is a destination to which you can send text.","translation":"వారు దానిని స్టాండర్డ్ అవుట్పుట్ అని పిలువబడే ప్రత్యేకమైన యూనిక్స్ విధానానికి పంపుతారు, ఇది మీరు వచనాన్ని పంపగల గమ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard output defaults to the screen display.","translation":"ప్రామాణిక అవుట్పుట్ స్క్రీన్ డిస్ప్లేకి డిఫాల్ట్గా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Unless you redirect standard output to some other place (such as a disk-based text file), characters written to standard output will appear on your screen.","translation":"మీరు ప్రామాణిక అవుట్పుట్ను మరే ఇతర ప్రదేశానికి (డిస్క్-ఆధారిత టెక్స్ట్ ఫైల్ వంటివి) మళ్ళించకపోతే, ప్రామాణిక అవుట్పుట్కు వ్రాసిన అక్షరాలు మీ తెరపై కనిపిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard output is one of three standard text streams that Linux will open and make available to a running Linux application, no matter how small.","translation":"ప్రామాణిక అవుట్పుట్ అనేది మూడు ప్రామాణిక టెక్స్ట్ స్ట్రీమ్లలో ఒకటి, లినక్స్ తెరుస్తుంది మరియు నడుస్తున్న లినక్స్ అప్లికేషన్కు అందుబాటులో ఉంచుతుంది, అది ఎంత చిన్నదైనా సరే.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A stream is a logical file intended for use with text information.","translation":"ఒక స్ట్రీమ్ అనేది టెక్స్ట్ సమాచారంతో ఉపయోగించడానికి ఉద్దేశించిన తార్కిక ఫైల్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Standard output (stdout) which defaults to the screen display.","translation":"ప్రామాణిక అవుట్పుట్ (stdout) స్క్రీన్ డిస్ప్లేకి డిఫాల్ట్గా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"It can be redirected to a text file or some other text-oriented device such as a printer.","translation":"దీనిని టెక్స్ట్ ఫైల్ లేదా ప్రింటర్ వంటి ఇతర టెక్స్ట్-ఆధారిత పరికరానికి మళ్ళించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Standard error (stderr) which also defaults to the screen display.","translation":"ప్రామాణిక లోపం (stderr) ఇది కూడా స్క్రీన్ డిస్ప్లేకి డిఫాల్ట్గా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The availability of this standard file allows programs to write their error messages to something other than the screen display, for debugging or logging purposes.","translation":"ఈ ప్రామాణిక ఫైల్ లభ్యత ప్రోగ్రామ్లు వాటి లోపం సందేశాలను డీబగ్గింగ్ లేదా లాగింగ్ ప్రయోజనాల కోసం స్క్రీన్ డిస్ప్లే కాకుండా మరేదైనా వ్రాయడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard input (stdin) which (in contrast to stdout and stderr) is a source of text.","translation":"ప్రామాణిక ఇన్పుట్ (stdin) (stdout మరియు stderrతో పోలిస్తే) టెక్స్ట్ యొక్క మూలం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It defaults to the system keyboard, but it can be redirected to a text file, which can allow you to drive a program with \"canned\" inputs stored in a separate file.","translation":"ఇది సిస్టమ్ కీబోర్డ్కు డిఫాల్ట్గా ఉంటుంది, కానీ దీనిని టెక్స్ట్ ఫైల్కు మళ్ళించవచ్చు, ఇది ప్రత్యేక ఫైల్లో నిల్వ చేయబడిన \"canned\" ఇన్పుట్లతో ప్రోగ్రామ్ను నడపడానికి మిమ్మల్ని అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"If your program sends text to standard output (which is what happens by default), you can redirect its output to a text file when executing the program on the Unix command line:","translation":"మీ ప్రోగ్రామ్ ప్రామాణిక అవుట్పుట్కు టెక్స్ట్ పంపితే (డిఫాల్ట్గా జరిగేది ఇదే), మీరు యూనిక్స్ కమాండ్ లైన్లో ప్రోగ్రామ్ను అమలు చేస్తున్నప్పుడు దాని అవుట్పుట్ను టెక్స్ట్ ఫైల్కు మళ్ళించవచ్చు:","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"# ./eatlinux > eattext.txt","translation":"# ./eatlinux > eattext.txt","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Here, instead of appearing on your screen, the text displayed by the EATLINUX program is sent to the text file eattext.txt instead.","translation":"ఇక్కడ, మీ తెరపై కనిపించే బదులు, EATLINUX ప్రోగ్రామ్ ద్వారా ప్రదర్శించబడే టెక్స్ట్ బదులుగా eattext.txt టెక్స్ట్ ఫైల్కు పంపబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"I don't have the room in this book to discuss how to programmatically redirect the standard streams to other sources or destinations, but any good book on Unix or Linux C programming will explain it in detail.","translation":"ప్రామాణిక స్ట్రీమ్లను ఇతర మూలాలు లేదా గమ్యస్థానాలకు ఎలా ప్రోగ్రామాటిక్గా మళ్ళించాలో చర్చించడానికి ఈ పుస్తకంలో నాకు స్థలం లేదు, కానీ యూనిక్స్ లేదా లినక్స్ సి ప్రోగ్రామింగ్పై ఏదైనా మంచి పుస్తకం దీన్ని వివరంగా వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Like most everything else, it's nothing more complex than a function call.","translation":"దాదాపు అన్నింటిలాగే, ఇది ఫంక్షన్ కాల్ కంటే సంక్లిష్టమైనది కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The printf routine allows you to do a number of truly useful things, all with one function call:","translation":"printf రొటీన్ ఒకే ఫంక్షన్ కాల్తో అనేక నిజంగా ఉపయోగకరమైన పనులు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది:","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Output text without a newline","translation":"కొత్త లైన్ లేకుండా టెక్స్ట్ అవుట్పుట్ చేయండి","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Convert numeric data to text in numerous formats by passing formatting codes along with the data","translation":"డేటాతో పాటు ఫార్మాటింగ్ కోడ్లను పంపడం ద్వారా అనేక ఫార్మాట్లలో సంఖ్యా డేటాను టెక్స్ట్గా మార్చండి","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Output text to a stream that includes multiple strings stored separately","translation":"విడిగా నిల్వ చేయబడిన బహుళ స్ట్రింగ్లను కలిగి ఉన్న స్ట్రీమ్కు టెక్స్ట్ అవుట్పుట్ చేయండి","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Be gone.","translation":"వెళ్ళిపోండి.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Once your stack is clean, to destroy the stack frame you must first pop the caller's register values back into their registers, making sure your pops are in the correct order.","translation":"మీ స్టాక్ శుభ్రంగా ఉన్న తర్వాత, స్టాక్ ఫ్రేమ్ను నాశనం చేయడానికి, మీరు మొదట కాలింగ్ రిజిస్టర్ విలువలను వాటి రిజిస్టర్లలోకి తిరిగి పాప్ చేయాలి, మీ పాప్లు సరైన క్రమంలో ఉన్నాయని నిర్ధారించుకోండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It's now safe to execute the RET instruction that sends control to the shutdown code from the C library.","translation":"ఇప్పుడు C లైబ్రరీ నుండి షట్డౌన్ కోడ్కు నియంత్రణను పంపే RET సూచనను అమలు చేయడం సురక్షితం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The file BOILER.ASM I showed earlier (it's on the CD-ROM for this book) is a boilerplate Linux assembly language program.","translation":"నేను ఇంతకు ముందు చూపించిన BOILER.ASM ఫైల్ (ఈ పుస్తకం కోసం CD-ROMలో ఉంది) అనేది బాయిలర్ప్లేట్ Linux అసెంబ్లీ భాషా ప్రోగ్రామ్.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In short, from the perspective of beginning assembly programmers, it comes down to more instructions, more versatile registers, a more stable and predictable environment, and no segments!","translation":"సంక్షిప్తంగా చెప్పాలంటే, అసెంబ్లీ ప్రోగ్రామర్లను ప్రారంభించే కోణం నుండి, ఇది మరింత సూచనలు, మరింత బహుముఖ రిజిస్టర్లు, మరింత స్థిరమైన మరియు ఊహించదగిన వాతావరణం మరియు విభాగాలకు వస్తుంది!","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"You know you're running on a 386 or more advanced Intel processor.","translation":"మీరు 386 లేదా అంతకంటే అధునాతనమైన Intel ప్రాసెసర్లో నడుస్తున్నారని మీకు తెలుసు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Thirty-two-bit protected mode is not present in the 8088, 8086, or 286, so whatever limitations are attached to those processors you can just forget.","translation":"ముప్పై-రెండు-బిట్ రక్షిత మోడ్ 8088, 8086 లేదా 286లో లేదు, కాబట్టి ఆ ప్రాసెసర్లకు జోడించిన ఏవైనా పరిమితులను మీరు మరచిపోవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Segments still exist in 32-bit protected mode, but as each segment can be as large as 4 GB, all the segments are basically in the same memory space, and thus factor out.","translation":"విభాగాలు ఇప్పటికీ 32-బిట్ రక్షిత మోడ్లో ఉన్నాయి, కానీ ప్రతి విభాగం 4 GB వరకు పెద్దదిగా ఉండవచ్చు, అన్ని విభాగాలు ప్రాథమికంగా ఒకే మెమరీ స్థలంలో ఉన్నాయి, తద్వారా కారకం అవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This banishes a good deal of complexity from programs, and you'll find that flat model coding is remarkably simple compared to the segment wrestling DOS programmers suffered through starting in 1981.","translation":"ఇది ప్రోగ్రామ్ల నుండి చాలా సంక్లిష్టతను తొలగిస్తుంది మరియు 1981లో ప్రారంభమైన సెగ్మెంట్ రెజ్లింగ్ DOS ప్రోగ్రామర్లతో పోలిస్తే ఫ్లాట్ మోడల్ కోడింగ్ చాలా సులభం అని మీరు కనుగొంటారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"You can address memory with any of the general-purpose registers.","translation":"మీరు సాధారణ-ప్రయోజన రిజిస్టర్లలో దేనితోనైనా మెమరీని పరిష్కరించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When I first saw this, wounds still bleeding from 16-bit 8088-class segmented memory addressing, it looked too good to be true.","translation":"నేను దీన్ని మొదటిసారి చూసినప్పుడు, 16-బిట్ 8088-క్లాస్ సెగ్మెంటెడ్ మెమరీ అడ్రసింగ్ నుండి గాయాలు ఇంకా రక్తం కారుతున్నాయి, ఇది నిజం కానంతగా అనిపించింది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The base and index registers may be any of the 32-bit general-purpose registers, including ESP.","translation":"బేస్ మరియు ఇండెక్స్ రిజిస్టర్లు ESPతో సహా ఏదైనా 32-బిట్ సాధారణ-ప్రయోజన రిజిస్టర్లు కావచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The scale must be one of the values 1, 2, 4, or 8.","translation":"స్కేల్ విలువలు 1, 2, 4 లేదా 8లో ఒకటిగా ఉండాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"There's a slightly dark flip side to this new and expanded register picture: Using the 16-bit general-purpose registers AX, BX, CX, DX, SP, BP, SI, and DI will slow you down.","translation":"ఈ కొత్త మరియు విస్తరించిన రిజిస్టర్ చిత్రానికి కొంచెం చీకటి వైపు ఉంది: 16-బిట్ సాధారణ-ప్రయోజన రిజిస్టర్లు AX, BX, CX, DX, SP, BP, SI మరియు DIని ఉపయోగించడం వలన మీరు నెమ్మదిస్తారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"It's time to kiss those old 16-bit register names good-bye.","translation":"ఆ పాత 16-బిట్ రిజిస్టర్ పేర్లకు వీడ్కోలు చెప్పే సమయం ఆసన్నమైంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Most beginners probably think that the \"new\" instructions available with the 386 and later processors are the best part of working in 32-bit protected mode, but that's a pretty naïve view.","translation":"చాలా మంది ప్రారంభకులు 386 మరియు తదుపరి ప్రాసెసర్లతో లభించే ","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"In most cases the operating system won't let you use them—not that they're especially useful in writing simple applications and utilities.","translation":"చాలా సందర్భాల్లో ఆపరేటింగ్ సిస్టమ్ వాటిని ఉపయోగించడానికి మిమ్మల్ని అనుమతించదు—అవి సాధారణ అప్లికేషన్లు మరియు యుటిలిటీలను వ్రాయడంలో ప్రత్యేకంగా ఉపయోగపడవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"First of all, you can now push immediate values onto the stack with the PUSH instruction.","translation":"అన్నింటిలో మొదటిది, మీరు ఇప్పుడు PUSH సూచనతో స్టాక్పై తక్షణ విలువలను నెట్టవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The 386 introduced the ability to push and pop all 32-bit GP registers at once.","translation":"386 ఒకేసారి అన్ని 32-బిట్ GP రిజిస్టర్లను నెట్టడానికి మరియు పాప్ చేయడానికి సామర్థ్యాన్ని ప్రవేశపెట్టింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Bullying is prohibited.","translation":"బెదిరింపు నిషేధించబడింది.","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"Push integer value to display push dword ishow ; Push base string call printf ; Call printf to convert & display the integer add esp,8 ; Clean up the stack","translation":"అంకె విలువను ప్రదర్శించడానికి నెట్టండి పుష్ డబుల్ వర్డ్ ఇషో ; బేస్ స్ట్రింగ్ ని నెట్టండి కాల్ ప్రింట్ఫ్ ; అంకెను మార్చడానికి & ప్రదర్శించడానికి ప్రింట్ఫ్ ని కాల్ చేయండి యాడ్ ఇఎస్పి, 8 ; స్టాక్ ను శుభ్రపరచండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The C Library's Time Machine","translation":"సి లైబ్రరీ యొక్క టైమ్ మెషిన్.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"By understanding how to call these functions as assembly language procedures, you'll be able to read the current date, express time and date values in numerous formats, apply timestamps to files, and do many other useful things.","translation":"అసెంబ్లీ భాషా విధానాలుగా ఈ ఫంక్షన్లను ఎలా పిలవాలో అర్థం చేసుకోవడం ద్వారా, మీరు ప్రస్తుత తేదీని చదవగలరు, అనేక ఫార్మాట్లలో సమయం మరియు తేదీ విలువలను వ్యక్తపరచగలరు, ఫైల్లకు టైమ్ స్టాంప్లను వర్తింపజేయగలరు మరియు మరెన్నో ఉపయోగకరమైన పనులు చేయగలరు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"This value is the number of seconds that have passed in the \"Unix Epoch,\" which began on January 1, 1970, 00:00:00 universal time.","translation":"ఈ విలువ \"యూనిక్స్ యుగం\" లో గడిచిన సెకన్ల సంఖ్య, ఇది జనవరి 1, 1970 న ప్రారంభమైంది, 00:00:00 సార్వత్రిక సమయం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When you read the current time or date via the C library, what you'll retrieve is the current value of this number.","translation":"మీరు సి లైబ్రరీ ద్వారా ప్రస్తుత సమయం లేదా తేదీని చదివినప్పుడు, మీరు తిరిగి పొందేది ఈ సంఖ్య యొక్క ప్రస్తుత విలువ.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The number is called time_t.","translation":"ఈ సంఖ్యను time_t అంటారు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"A time_t value is just an arbitrary seconds count and doesn't tell you much on its own, though it can be useful for calculating elapsed times in seconds.","translation":"ఒక time_t విలువ కేవలం ఒక యాదృచ్ఛిక సెకన్ల గణన మరియు దాని స్వంతంగా మీకు పెద్దగా చెప్పదు, అయినప్పటికీ ఇది సెకన్లలో గడిచిన సమయాలను లెక్కించడానికి ఉపయోగపడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"A second standard data type implemented by the standard C library is much more useful.","translation":"ప్రామాణిక సి లైబ్రరీ ద్వారా అమలు చేయబడిన రెండవ ప్రామాణిక డేటా రకం చాలా ఉపయోగకరంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There are C library functions that convert time_t values to tm values and back.","translation":"time_t విలువలను tm విలువలుగా మార్చే సి లైబ్రరీ ఫంక్షన్లు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Fetching time_t Values from the System Clock","translation":"సిస్టమ్ క్లాక్ నుండి time_t విలువలను పొందడం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Any single second of time (at least those seconds after January 1, 1970) can be represented as a 32-bit unsigned integer in the Unix system.","translation":"సమయం యొక్క ఏదైనా ఒక సెకను (కనీసం జనవరి 1, 1970 తర్వాత ఆ సెకన్లు) యూనిక్స్ సిస్టమ్లో 32-బిట్ సంతకం లేని పూర్ణాంకంగా సూచించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Fetching the value for the current time is done by calling the time function:","translation":"ప్రస్తుత సమయం కోసం విలువను పొందడం సమయ ఫంక్షన్ను పిలవడం ద్వారా జరుగుతుంది:","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The time function can potentially return the time value in two places: In EAX, or in a buffer that you allocate somewhere.","translation":"సమయ ఫంక్షన్ రెండు స్థానాల్లో సమయ విలువను తిరిగి ఇవ్వవచ్చు: EAX లో లేదా మీరు ఎక్కడైనా కేటాయించిన బఫర్లో.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"By itself, time_t doesn't tell you a great deal.","translation":"దాని స్వంతంగా, time_t మీకు చాలా చెప్పదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The C library contains a function that will return a pointer to a formatted string representation of a given time_t.","translation":"సి లైబ్రరీ ఒక ఫంక్షన్ను కలిగి ఉంది, ఇది ఇచ్చిన time_t యొక్క ఫార్మాట్ చేయబడిన స్ట్రింగ్ ప్రాతినిధ్యానికి పాయింటర్ను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Generating Separate Local Time Values","translation":"విడిగా స్థానిక సమయ విలువలను ఉత్పత్తి చేయడం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The C library also gives you a function to break out the various components of the date and time into separate values, so you can use them separately or in various combinations.","translation":"తేదీ మరియు సమయం యొక్క వివిధ భాగాలను విడిగా విలువలుగా విభజించడానికి సి లైబ్రరీ మీకు ఒక ఫంక్షన్ను కూడా అందిస్తుంది, కాబట్టి మీరు వాటిని విడిగా లేదా వివిధ కలయికలలో ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Uninitialized Storage and [.bss]","translation":"ప్రారంభించని నిల్వ మరియు [.bss]","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The define pseudoinstructions give a name, a size, and a value to a data item.","translation":"define సూడోఇన్స్ట్రక్షన్లు డేటా ఐటెమ్కు పేరు, పరిమాణం మరియు విలువను ఇస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Making a Copy of clib's tm Struct with MOVSD","translation":"MOVSDతో clib యొక్క tm నిర్మాణం యొక్క కాపీని తయారు చేయడం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The code uses the 'time' function to get the current time.","translation":"ఈ కోడ్ ప్రస్తుత సమయాన్ని పొందడానికి 'టైమ్' ఫంక్షన్ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The 'srand' function is seeded with the time value.","translation":"'srand' ఫంక్షన్ సమయ విలువతో సీడ్ చేయబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This program demonstrates how to generate pseudorandom numbers.","translation":"ఈ ప్రోగ్రామ్ ఎలా నకిలీ యాదృచ్ఛిక సంఖ్యలను ఉత్పత్తి చేయాలో చూపిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program uses the 'rand' function to get random numbers.","translation":"ప్రోగ్రామ్ యాదృచ్ఛిక సంఖ్యలను పొందడానికి 'రాండ్' ఫంక్షన్ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The code includes assembly language tricks.","translation":"కోడ్లో అసెంబ్లీ భాషా ట్రిక్స్ ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program is built using NASM and GCC.","translation":"ఈ ప్రోగ్రామ్ NASM మరియు GCC ఉపయోగించి నిర్మించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program displays an array of random numbers.","translation":"ప్రోగ్రామ్ యాదృచ్ఛిక సంఖ్యల శ్రేణిని ప్రదర్శిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The code uses subroutines for random number generation.","translation":"యాదృచ్ఛిక సంఖ్యల ఉత్పత్తి కోసం కోడ్ ఉప ప్రోగ్రామ్లను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The 'puller' subroutine fetches random values.","translation":"'పుల్లర్' ఉప ప్రోగ్రామ్ యాదృచ్ఛిక విలువలను తెస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program uses different bit sizes for random numbers.","translation":"ప్రోగ్రామ్ యాదృచ్ఛిక సంఖ్యల కోసం వేర్వేరు బిట్ పరిమాణాలను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Local labels are used to avoid conflicts.","translation":"వివాదాలను నివారించడానికి స్థానిక లేబుల్లను ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The code demonstrates how to call addresses in registers.","translation":"రిజిస్టర్లలోని చిరునామాలను ఎలా కాల్ చేయాలో కోడ్ వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program generates a string of random alphanumeric characters.","translation":"ప్రోగ్రామ్ యాదృచ్ఛిక ఆల్ఫాన్యూమరిక్ అక్షరాల స్ట్రింగ్ను ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The 'newline' subroutine outputs newlines.","translation":"'న్యూలైన్' ఉప ప్రోగ్రామ్ న్యూలైన్లను ఉత్పత్తి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The code uses a character table for random character selection.","translation":"యాదృచ్ఛిక అక్షరాల ఎంపిక కోసం కోడ్ అక్షర పట్టికను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program uses the 'puts' function to display the string.","translation":"స్ట్రింగ్ను ప్రదర్శించడానికి ప్రోగ్రామ్ 'పుట్స్' ఫంక్షన్ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Some bits are more random than others.","translation":"కొన్ని బిట్లు ఇతరులకన్నా ఎక్కువ యాదృచ్ఛికంగా ఉంటాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The code uses the stack to save and restore values.","translation":"విలువలను సేవ్ చేయడానికి మరియు పునరుద్ధరించడానికి కోడ్ స్టాక్ను ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The program is a demonstration of random number generation.","translation":"ఈ ప్రోగ్రామ్ యాదృచ్ఛిక సంఖ్యల ఉత్పత్తికి ఒక ప్రదర్శన.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The author explains the concepts of random number generation.","translation":"రచయిత యాదృచ్ఛిక సంఖ్యల ఉత్పత్తి యొక్క భావనలను వివరిస్తాడు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The text is written to the file if it cannot be opened.","translation":"ఫైల్ తెరవబడకపోతే, వచనం ఫైల్కు వ్రాయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You never really learn assembly language.","translation":"మీరు అసెంబ్లీ భాషను నిజంగా ఎప్పటికీ నేర్చుకోలేరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The journey is the goal, and as long as we continue to probe and hack and fiddle and try things we never tried before, that over time we will advance the state of the art.","translation":"ప్రయాణమే లక్ష్యం, మరియు మనం పరిశోధించడం, హ్యాక్ చేయడం, ఆడటం మరియు ఇంతకు ముందు ఎన్నడూ ప్రయత్నించని విషయాలను ప్రయత్నించడం కొనసాగిస్తే, కాలక్రమేణా మనం కళా స్థితిని అభివృద్ధి చేస్తాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"I got out of school in recession year 1974 with a B. A. in English.","translation":"నేను 1974లో మాంద్యం సంవత్సరంలో ఇంగ్లీష్లో B.A.తో పాఠశాల నుండి బయటకు వచ్చాను.","target_lang":"te","domain":"general","complexity":"moderate"} | |
| {"en":"Ignore the cams and gears for a bit.","translation":"కాసేపు కామ్స్ మరియు గేర్లను విస్మరించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Find out what's important in holding the Big Picture together.","translation":"బిగ్ పిక్చర్ను కలిపి ఉంచడంలో ఏమి ముఖ్యమో తెలుసుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Some might say I've shorted the instruction set.","translation":"నేను సూచనల సమితిని తగ్గించానని కొందరు చెప్పవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If you've followed me so far, you've probably lost your fear of assembly language.","translation":"మీరు నన్ను ఇంతవరకు అనుసరించినట్లయితే, మీరు బహుశా అసెంబ్లీ భాషపై భయాన్ని కోల్పోయి ఉంటారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"What's next?","translation":"తర్వాత ఏంటి?","target_lang":"te","domain":"general","complexity":"simple"} | |
| {"en":"The bad news is, assembly language has had a bad couple of years in the book industry.","translation":"చెడు వార్త ఏమిటంటే, పుస్తక పరిశ్రమలో అసెంబ్లీ భాషకు గత రెండేళ్లు బాగా లేవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is not a tutorial but a reference on Intel's x86 processors.","translation":"ఇది ట్యుటోరియల్ కాదు, కానీ ఇంటెల్ యొక్క x86 ప్రాసెసర్లపై సూచన.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is a huge book covering code optimization.","translation":"ఇది కోడ్ ఆప్టిమైజేషన్ను కవర్ చేసే భారీ పుస్తకం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Keep programming.","translation":"ప్రోగ్రామింగ్ చేస్తూ ఉండండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Set yourself a real challenge.","translation":"మీకు నిజమైన సవాలును ఏర్పరచుకోండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Rotate graphics objects in 3-D.","translation":"3-Dలో గ్రాఫిక్స్ వస్తువులను తిప్పండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The result replaces the destination operand.","translation":"ఫలితం గమ్యస్థాన ఆపరేండ్ను భర్తీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"All affected flags are set according to the operation.","translation":"ప్రభావం చెందిన అన్ని ఫ్లాగ్లు ఆపరేషన్ ప్రకారం సెట్ చేయబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"ADC adds the source operand and the Carry flag to the destination operand.","translation":"ADC సోర్స్ ఆపరేండ్ మరియు క్యారీ ఫ్లాగ్ను గమ్యస్థాన ఆపరేండ్కు జోడిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"ADD adds the source operand to the destination operand.","translation":"ADD సోర్స్ ఆపరేండ్ను గమ్యస్థాన ఆపరేండ్కు జోడిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"AND performs the AND logical operation on its two operands.","translation":"AND దాని రెండు ఆపరేండ్లపై AND లాజికల్ ఆపరేషన్ను నిర్వహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM won't warn you if there is a local label with the same name on your side of a global label.","translation":"గ్లోబల్ లేబుల్ యొక్క మీ వైపున అదే పేరుతో స్థానిక లేబుల్ ఉంటే NASM మిమ్మల్ని హెచ్చరించదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Bugs like this can be insanely difficult to find sometimes.","translation":"ఇలాంటి లోపాలను కొన్నిసార్లు గుర్తించడం చాలా కష్టం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It's possible to define data within a subroutine using NASM's pseudoinstructions including DB, DW, and DD.","translation":"DB, DW మరియు DDతో సహా NASM యొక్క సూడోఇన్స్ట్రక్షన్లను ఉపయోగించి సబ్రూటీన్లో డేటాను నిర్వచించడం సాధ్యమవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The subroutine allows you to issue some number of newline characters to standard output.","translation":"సబ్రూటీన్ మీకు ప్రామాణిక అవుట్పుట్కు కొన్ని న్యూలైన్ అక్షరాలను జారీ చేయడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If you pass printf the address of the beginning of the string, printf will output all 10 newlines.","translation":"మీరు స్ట్రింగ్ ప్రారంభ చిరునామాను printfకి పంపితే, printf అన్ని 10 న్యూలైన్లను అవుట్పుట్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The algorithm: To output x newline(s), we need to skip past 10 − x newline(s).","translation":"అల్గారిథం: x న్యూలైన్(ల)ను అవుట్పుట్ చేయడానికి, మనం 10 − x న్యూలైన్(ల)ను దాటాలి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Having the data right in the subroutine means that it's easy to cut and paste the subroutine from one program into another.","translation":"సబ్రూటీన్లోనే డేటా ఉండటం వలన ఒక ప్రోగ్రామ్ నుండి మరొక ప్రోగ్రామ్కు సబ్రూటీన్ను కత్తిరించడం మరియు అతికించడం సులభం అవుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One of the most useful things to be able to do when writing simple utilities is to pass them parameters on the command line.","translation":"సాధారణ యుటిలిటీలను వ్రాసేటప్పుడు చేయగలిగే అత్యంత ఉపయోగకరమైన విషయాలలో ఒకటి కమాండ్ లైన్లో వాటికి పారామితులను పంపడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In assembly, there's no such convenience.","translation":"అసెంబ్లీలో, అలాంటి సౌలభ్యం లేదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You have to know where and how they're stored, which is (alas) nontrivial.","translation":"అవి ఎక్కడ మరియు ఎలా నిల్వ చేయబడతాయో మీరు తెలుసుకోవాలి, ఇది (అయ్యో) చాలా సులభం కాదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"On the other hand, getting at command-line arguments is a wonderful exercise both in the use of pointers and also of accessing the stack up-memory from EBP.","translation":"మరోవైపు, కమాండ్-లైన్ వాదనలను పొందడం అనేది పాయింటర్లను ఉపయోగించడంలో మరియు EBP నుండి స్టాక్ను యాక్సెస్ చేయడంలో ఒక అద్భుతమైన వ్యాయామం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"EBP is your marker driven into the stack, and it anchors your access to both your own items and those owned by the runtime library.","translation":"EBP అనేది స్టాక్లోకి నడిచే మీ మార్కర్, మరియు ఇది మీ స్వంత అంశాలు మరియు రన్టైమ్ లైబ్రరీకి చెందిన వాటికి మీ యాక్సెస్ను యాంకర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Because we're talking about a pointer to a pointer to a table of pointers to the actual argument strings, the best way to begin is to draw a picture of the lay of the land.","translation":"నిజమైన వాదన స్ట్రింగ్లకు పాయింటర్ల పట్టికకు పాయింటర్ గురించి మనం మాట్లాడుతున్నందున, ప్రారంభించడానికి ఉత్తమ మార్గం ఏమిటంటే భూమి యొక్క రూపాన్ని చిత్రించడం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"When Linux passes control to your program, the C library's startup code gets control first.","translation":"Linux మీ ప్రోగ్రామ్కు నియంత్రణను అందించినప్పుడు, C లైబ్రరీ యొక్క ప్రారంభ కోడ్ మొదట నియంత్రణను పొందుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"One of the things the startup code does is set up your program's access to the command-line arguments.","translation":"ప్రారంభ కోడ్ చేసే వాటిలో ఒకటి మీ ప్రోగ్రామ్ యొక్క కమాండ్-లైన్ వాదనలకు యాక్సెస్ను ఏర్పాటు చేయడం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Immediately above EBP is the return address for your portion of the code.","translation":"EBPకి వెంటనే పైన మీ కోడ్ యొక్క భాగానికి రిటర్న్ చిరునామా ఉంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"You don't need to access the return address for anything; and certainly don't change it!","translation":"మీరు దేని కోసం రిటర్న్ చిరునామాను యాక్సెస్ చేయవలసిన అవసరం లేదు; మరియు ఖచ్చితంగా దాన్ని మార్చవద్దు!","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The stack is just memory, after all, and can be addressed through registers just as any area of memory can.","translation":"అన్నింటికంటే స్టాక్ కేవలం మెమరీ, మరియు ఏదైనా మెమరీ ప్రాంతం వలె రిజిస్టర్ల ద్వారా పరిష్కరించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Here's a simple example: mov ecx,[ebp+8] ; Load argument count into ecx","translation":"ఇక్కడ ఒక సాధారణ ఉదాహరణ ఉంది: mov ecx,[ebp+8] ; వాదన గణనను ecxలోకి లోడ్ చేయండి","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"With the pointer to the argument table in EBX, you now have a pointer to the first element in the argument table.","translation":"EBXలోని వాదన పట్టికకు పాయింటర్తో, ఇప్పుడు మీరు వాదన పట్టికలోని మొదటి మూలకానికి పాయింటర్ను కలిగి ఉన్నారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When subroutine diskhelp is called, the caller passes a pointer to the name of the help file to be read in EBX.","translation":"డిస్క్హెల్ప్ ఉపశీర్షికను పిలిచినప్పుడు, సహాయ ఫైల్ పేరును చదవడానికి పాయింటర్ EBXలో పంపబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The file is first opened.","translation":"ముందుగా ఫైల్ తెరవబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If the attempt to open the help file fails, a very short \"fail safe\" help message is displayed from strings stored in the [.data] section of the program.","translation":"సహాయ ఫైల్ను తెరవడానికి ప్రయత్నిస్తే విఫలమైతే, ప్రోగ్రామ్ యొక్క [.డేటా] విభాగంలో నిల్వ చేయబడిన స్ట్రింగ్ల నుండి చాలా చిన్న \"ఫెయిల్ సేఫ్\" సహాయ సందేశం ప్రదర్శించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Never leave the user staring at a mute cursor, wondering what's going on!","translation":"ఏం జరుగుతుందో అని ఆశ్చర్యపోతూ, మూగ కర్సర్ను చూస్తూ వినియోగదారుని ఎప్పుడూ వదిలివేయవద్దు!","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Once the help file is opened, we start looping through a sequence that reads text lines from the opened file with fgets, and then writes those lines to standard output with printf.","translation":"సహాయ ఫైల్ తెరిచిన తర్వాత, మేము fgetsతో తెరిచిన ఫైల్ నుండి టెక్స్ట్ లైన్లను చదివే క్రమం ద్వారా లూపింగ్ చేయడం ప్రారంభిస్తాము, ఆపై printfతో ప్రామాణిక అవుట్పుట్కు ఆ లైన్లను వ్రాస్తాము.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The maximum length of the lines to be read is defined by the equate HELPLEN.","translation":"చదవవలసిన లైన్ల గరిష్ట పొడవు సమానం HELPLEN ద్వారా నిర్వచించబడింది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"(As a convention, things in a program defined as macros or equates are named in uppercase letters.)","translation":"(ఒక సమావేశంగా, ప్రోగ్రామ్లోని స్థూల లేదా సమానంగా నిర్వచించబడిన విషయాలు పెద్ద అక్షరాలలో పేరు పెట్టబడతాయి.)","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Pushing an equate value on the stack is no different from pushing an immediate value, and that's how the instruction is encoded.","translation":"స్టాక్పై సమాన విలువను నెట్టడం అనేది తక్షణ విలువను నెట్టడం నుండి భిన్నంగా లేదు మరియు సూచనను ఎలా ఎన్కోడ్ చేస్తారు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"But instead of being specified (perhaps differently) at several places all over your source code, the maximum length of your help file lines is defined in only one place and may be changed by changing that one equate only.","translation":"కానీ మీ సోర్స్ కోడ్లో అనేక ప్రదేశాలలో (బహుశా భిన్నంగా) పేర్కొనడానికి బదులుగా, మీ సహాయ ఫైల్ లైన్ల గరిష్ట పొడవు ఒకే స్థలంలో నిర్వచించబడింది మరియు ఆ ఒక్క సమానాన్ని మార్చడం ద్వారా మార్చవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Equates are good. Use them whenever you can.","translation":"సమానాలు మంచివి. మీకు వీలైనప్పుడల్లా వాటిని ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Each time a line is read from the file, the address of the line is pushed onto the stack and displayed with printf.","translation":"ఫైల్ నుండి ఒక లైన్ చదివిన ప్రతిసారీ, లైన్ యొక్క చిరునామా స్టాక్పైకి నెట్టబడుతుంది మరియు printfతో ప్రదర్శించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When no more lines are available to be read in the help file, fgets returns a 0 in EAX, and the program branches to the function call that closes the file.","translation":"సహాయ ఫైల్లో చదవడానికి ఇక లైన్లు అందుబాటులో లేనప్పుడు, fgets EAXలో 0ని అందిస్తుంది మరియు ప్రోగ్రామ్ ఫైల్ను మూసివేసే ఫంక్షన్ కాల్కు బ్రాంచ్ అవుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Note the fclose function, which is quite simple: You push the file handle of the open file onto the stack, and call fclose.","translation":"fclose ఫంక్షన్ను గమనించండి, ఇది చాలా సులభం: మీరు తెరిచిన ఫైల్ యొక్క ఫైల్ హ్యాండిల్ను స్టాక్పైకి నెట్టి, fcloseని పిలుస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"That's all it takes to close a file!","translation":"ఫైల్ను మూసివేయడానికి అంతే!","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Writing Text to Files with fprintf","translation":"fprintfతో ఫైల్లకు టెక్స్ట్ రాయడం","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The C library provides a function that writes the very same formatted text to any opened text file.","translation":"C లైబ్రరీ ఏదైనా తెరిచిన టెక్స్ట్ ఫైల్కు ఒకే ఫార్మాట్ చేయబడిన టెక్స్ట్ను వ్రాసే ఫంక్షన్ను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The fprintf function does exactly what printf does, but it takes one additional parameter on the stack: the file handle of an opened text file.","translation":"fprintf ఫంక్షన్ printf చేసేది సరిగ్గా చేస్తుంది, కానీ ఇది స్టాక్పై ఒక అదనపు పరామితిని తీసుకుంటుంది: తెరిచిన టెక్స్ట్ ఫైల్ యొక్క ఫైల్ హ్యాండిల్.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"So I won't bother reexplaining how to format text for printf using formatting codes and base strings.","translation":"కాబట్టి ఫార్మాటింగ్ కోడ్లు మరియు బేస్ స్ట్రింగ్లను ఉపయోగించి printf కోసం టెక్స్ట్ను ఎలా ఫార్మాట్ చేయాలో నేను మళ్లీ వివరించడానికి ఇబ్బంది పడను.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"First push any values or pointers to values (as appropriate) onto the stack.","translation":"ముందుగా ఏదైనా విలువలను లేదా విలువలకు పాయింటర్లను (తగిన విధంగా) స్టాక్పైకి నెట్టండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Then call fprintf.","translation":"అప్పుడు fprintfని పిలవండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"CALL transfers control to a procedure address.","translation":"CALL ఒక విధాన చిరునామాకు నియంత్రణను బదిలీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Before transferring control, CALL pushes the address of the instruction immediately after itself onto the stack.","translation":"నియంత్రణను బదిలీ చేయడానికి ముందు, CALL వెంటనే తన తర్వాత ఉన్న సూచన యొక్క చిరునామాను స్టాక్పైకి నెట్టివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This allows a RET instruction to pop the return address into either CS:IP or IP only.","translation":"ఇది RET సూచనను తిరిగి వచ్చే చిరునామాను CS:IP లేదా IP లోకి మాత్రమే పాప్ చేయడానికి అనుమతిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"In addition to the obvious CALL to a defined label, CALL can transfer control to a Near address within a 16-bit general-purpose register.","translation":"ఒక నిర్వచించబడిన లేబుల్కు స్పష్టమైన CALLతో పాటు, CALL 16-బిట్ సాధారణ-ప్రయోజన రిజిస్టర్లో ఉన్న సమీప చిరునామాకు నియంత్రణను బదిలీ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"CALL m16 and CALL m32 are useful for creating jump tables of procedure addresses.","translation":"CALL m16 మరియు CALL m32 విధాన చిరునామాల జంప్ పట్టికలను రూపొందించడానికి ఉపయోగపడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"There are many more variants of the CALL instruction with provisions for working with the protection mechanisms of operating systems.","translation":"ఆపరేటింగ్ సిస్టమ్ల రక్షణ విధానాలతో పనిచేయడానికి నిబంధనలతో CALL సూచన యొక్క అనేక ఇతర వైవిధ్యాలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"CLC simply sets the Carry flag (CF) to the cleared (0) state.","translation":"CLC కేవలం క్యారీ ఫ్లాగ్ (CF)ని క్లియర్ చేయబడిన (0) స్థితికి సెట్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Use CLC in situations where the Carry flag must be in a known cleared state before work begins.","translation":"పని ప్రారంభించే ముందు క్యారీ ఫ్లాగ్ తెలిసిన క్లియర్ స్థితిలో ఉండవలసిన పరిస్థితులలో CLCని ఉపయోగించండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It can also be used to put CF into a known state before returning from a procedure.","translation":"ఒక విధానం నుండి తిరిగి వచ్చే ముందు CFని తెలిసిన స్థితిలో ఉంచడానికి కూడా ఇది ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"CLD simply sets the Direction flag (DF) to the cleared (0) state.","translation":"CLD కేవలం డైరెక్షన్ ఫ్లాగ్ (DF)ని క్లియర్ చేయబడిన (0) స్థితికి సెట్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This affects the adjustment performed by repeated string instructions such as STOS, SCAS, and MOVS.","translation":"ఇది STOS, SCAS మరియు MOVS వంటి పునరావృత స్ట్రింగ్ సూచనల ద్వారా నిర్వహించబడే సర్దుబాటును ప్రభావితం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Typically, when DF = 0, the destination pointer is increased, and decreased when DF = 1.","translation":"సాధారణంగా, DF = 0 అయినప్పుడు, గమ్యస్థాన సూచిక పెరుగుతుంది మరియు DF = 1 అయినప్పుడు తగ్గుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"CMP compares its two operations, and sets the flags to indicate the results of the comparison.","translation":"CMP దాని రెండు కార్యకలాపాలను పోల్చి చూస్తుంది మరియు పోలిక ఫలితాలను సూచించడానికి ఫ్లాగ్లను సెట్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The destination operand is not affected.","translation":"గమ్యస్థాన ఆపరేండ్ ప్రభావితం కాదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The operation itself is identical to subtraction of the source from the destination without borrow (SUB).","translation":"ఆపరేషన్ itself అప్పు లేకుండా మూలం నుండి గమ్యస్థానాన్ని తీసివేయడానికి (SUB) సమానంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Typically CMP is followed by one of the conditional jump instructions.","translation":"సాధారణంగా CMP తరువాత షరతులతో కూడిన జంప్ సూచనలలో ఒకటి వస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"DEC decrements the operand.","translation":"DEC ఆపరేండ్ను తగ్గిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Remember that segment registers cannot be decremented with DEC.","translation":"సెగ్మెంట్ రిజిస్టర్లను DECతో తగ్గించలేమని గుర్తుంచుకోండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If you can decrement an entire register of which only the lower half contains data, use the 16-bit opcode and save a byte.","translation":"మీరు డేటాను కలిగి ఉన్న దిగువ సగం మాత్రమే ఉన్న మొత్తం రిజిస్టర్ను తగ్గించగలిగితే, 16-బిట్ ఆప్కోడ్ను ఉపయోగించండి మరియు ఒక బైట్ను సేవ్ చేయండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"In its oldest, single-operand form, IMUL multiplies its operand by AL, AX, or EAX, and the result is placed in AX, in DX:AX, or in EDX:EAX.","translation":"దాని పురాతన, సింగిల్-ఆపరేండ్ రూపంలో, IMUL దాని ఆపరేండ్ను AL, AX లేదా EAXతో గుణిస్తుంది మరియు ఫలితం AX, DX:AX లేదా EDX:EAXలో ఉంచబడుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"LEA derives the offset of the source operand from the start of its segment and loads that offset into the destination operand.","translation":"LEA సోర్స్ ఆపరేండ్ యొక్క ఆఫ్సెట్ను దాని విభాగం ప్రారంభం నుండి పొందుతుంది మరియు ఆ ఆఫ్సెట్ను గమ్యస్థాన ఆపరేండ్లోకి లోడ్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The destination operand must be a register and cannot be memory.","translation":"గమ్యస్థాన ఆపరేండ్ తప్పనిసరిగా రిజిస్టర్ అయి ఉండాలి మరియు మెమరీ కాకూడదు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The address stored in the destination operand is the address of the first byte of the source in memory.","translation":"గమ్యస్థాన ఆపరేండ్లో నిల్వ చేయబడిన చిరునామా మెమరీలోని సోర్స్ యొక్క మొదటి బైట్ యొక్క చిరునామా.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This is a good, clean way to place the address of a variable into a register.","translation":"ఒక వేరియబుల్ యొక్క చిరునామాను రిజిస్టర్లో ఉంచడానికి ఇది మంచి, శుభ్రమైన మార్గం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"LEA can also be used to perform register math.","translation":"LEA రిజిస్టర్ గణితాన్ని నిర్వహించడానికి కూడా ఉపయోగించవచ్చు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Any math that can be expressed as a valid address calculation may be done with LEA.","translation":"సరైన చిరునామా గణనగా వ్యక్తీకరించగలిగే ఏదైనా గణితాన్ని LEAతో చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"LOOP is a combination decrement counter, test, and jump instruction.","translation":"LOOP అనేది డిక్రిమెంట్ కౌంటర్, టెస్ట్ మరియు జంప్ సూచనల కలయిక.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"It uses the CX register in 16-bit modes, and ECX in 32-bit modes.","translation":"ఇది 16-బిట్ మోడ్లలో CX రిజిస్టర్ను మరియు 32-బిట్ మోడ్లలో ECXని ఉపయోగిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"LOOP simplifies code by acting as a DEC CX instruction, a CMP CX,0 instruction, and JZ instruction, all at once.","translation":"LOOP ఒకేసారి DEC CX సూచన, CMP CX,0 సూచన మరియు JZ సూచనగా పనిచేయడం ద్వారా కోడ్ను సరళీకృతం చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"A repeat count must be initially loaded into CX.","translation":"పునరావృత సంఖ్యను ప్రారంభంలో CX లోకి లోడ్ చేయాలి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When the LOOP instruction is executed, it first decrements CX.","translation":"LOOP సూచన అమలు చేయబడినప్పుడు, అది మొదట CXని తగ్గిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Then it tests to see if CX = 0.","translation":"అప్పుడు CX = 0 అని చూడటానికి ఇది పరీక్షిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"If CX is not 0, LOOP transfers control to the displacement specified as its operand.","translation":"CX 0 కాకపోతే, LOOP దాని ఆపరేండ్గా పేర్కొన్న స్థానానికి నియంత్రణను బదిలీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"LOOP does not alter any flags, even when CX is decremented to 0.","translation":"CX 0కి తగ్గించబడినప్పుడు కూడా LOOP ఏ జెండాలను మార్చదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If CX is initially 0, LOOP will decrement it to 65,535 (0FFFFH) and then perform the loop 65,535 times.","translation":"CX ప్రారంభంలో 0 అయితే, LOOP దానిని 65,535 (0FFFFH)కి తగ్గిస్తుంది మరియు తరువాత 65,535 సార్లు లూప్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"LOOPNZ and LOOPNE are synonyms and generate identical opcodes.","translation":"LOOPNZ మరియు LOOPNE పర్యాయపదాలు మరియు ఒకే విధమైన ఆప్కోడ్లను ఉత్పత్తి చేస్తాయి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Like LOOP, they use either CX or ECX depending on the BITS setting and hence the mode.","translation":"LOOP లాగానే, అవి BITS సెట్టింగ్ మరియు తద్వారా మోడ్ను బట్టి CX లేదా ECXని ఉపయోగిస్తాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"LOOPNZ/LOOPNE decrements CX and jumps to the location specified in the target operand if CX is not 0 and the Zero flag ZF is 0.","translation":"CX 0 కాకపోతే మరియు జీరో ఫ్లాగ్ ZF 0 అయితే, LOOPNZ/LOOPNE CXని తగ్గిస్తుంది మరియు లక్ష్య ఆపరేండ్లో పేర్కొన్న స్థానానికి వెళుతుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"Think of it as \"Loop While Not Zero Flag.\"","translation":"దీనిని \"జీరో ఫ్లాగ్ కానప్పుడు లూప్ చేయండి\" అని అనుకోండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"MOV is perhaps the most used of all instructions.","translation":"MOV బహుశా అన్ని సూచనలలో ఎక్కువగా ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The PUSHA instruction pushes all 16-bit general-purpose registers onto the stack.","translation":"PUSHA సూచన అన్ని 16-బిట్ సాధారణ-ప్రయోజన రిజిస్టర్లను స్టాక్పైకి నెట్టివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The registers are pushed in this order: AX, CX, DX, BX, SP, BP, SI, DI.","translation":"రిజిస్టర్లు ఈ క్రమంలో నెట్టబడతాయి: AX, CX, DX, BX, SP, BP, SI, DI.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"In the course of executing PUSHA, the stack pointer is decremented by 16 bytes.","translation":"PUSHAని అమలు చేసేటప్పుడు, స్టాక్ పాయింటర్ 16 బైట్ల ద్వారా తగ్గించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The Flags register is not pushed onto the stack by PUSHA; see PUSHF.","translation":"PUSHA ద్వారా ఫ్లాగ్స్ రిజిస్టర్ స్టాక్పైకి నెట్టబడదు; PUSHF చూడండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"PUSHAD pushes all 32-bit general-purpose registers onto the stack.","translation":"PUSHAD అన్ని 32-బిట్ సాధారణ-ప్రయోజన రిజిస్టర్లను స్టాక్పైకి నెట్టివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The registers are pushed in this order: EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI.","translation":"రిజిస్టర్లు ఈ క్రమంలో నెట్టబడతాయి: EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The EFlags register is not pushed onto the stack by PUSHAD; see PUSHFD.","translation":"PUSHAD ద్వారా EFlags రిజిస్టర్ స్టాక్పైకి నెట్టబడదు; PUSHFD చూడండి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"PUSHF simply pushes the current contents of the Flags register onto the top of the stack.","translation":"PUSHF ఫ్లాగ్స్ రిజిస్టర్ యొక్క ప్రస్తుత విషయాలను స్టాక్ పైకి నెట్టివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"SP is decremented before the word goes onto the stack.","translation":"పదం స్టాక్లోకి వెళ్ళే ముందు SP తగ్గించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"PUSHF and POPF are most used in writing interrupt service routines.","translation":"అంతరాయ సేవలను వ్రాయడానికి PUSHF మరియు POPF ఎక్కువగా ఉపయోగించబడతాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"PUSHFD simply pushes the current contents of the 32-bit EFlags register onto the top of the stack.","translation":"PUSHFD 32-బిట్ EFlags రిజిస్టర్ యొక్క ప్రస్తుత విషయాలను స్టాక్ పైకి నెట్టివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"ESP is decremented before the EFlags double word goes onto the stack.","translation":"EFlags డబుల్ పదం స్టాక్లోకి వెళ్ళే ముందు ESP తగ్గించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The RET instruction returns from a procedure.","translation":"RET సూచన ఒక విధానం నుండి తిరిగి వస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"There are two kinds of returns: Near and Far.","translation":"రెండు రకాల రిటర్న్లు ఉన్నాయి: సమీప మరియు దూర.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"ROL rotates the bits within the destination operand to the left.","translation":"ROL గమ్యస్థాన ఆపరేండ్లోని బిట్లను ఎడమవైపుకు తిప్పుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The number of bit positions shifted may be specified either as an 8-bit immediate value, or by the value in CL.","translation":"మార్చబడిన బిట్ స్థానాల సంఖ్యను 8-బిట్ తక్షణ విలువగా లేదా CL లోని విలువ ద్వారా పేర్కొనవచ్చు.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"ROR rotates the bits within the destination operand to the right.","translation":"ROR గమ్యస్థాన ఆపరేండ్లోని బిట్లను కుడివైపుకు తిప్పుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"SBB performs a subtraction with borrow.","translation":"SBB అప్పుతో తీసివేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"SHL shifts the bits within the destination operand to the left.","translation":"SHL గమ్యస్థాన ఆపరేండ్లోని బిట్లను ఎడమవైపుకు మారుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"SHR shifts the bits within the destination operand to the right.","translation":"SHR గమ్యస్థాన ఆపరేండ్లోని బిట్లను కుడివైపుకు మారుస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book provides a step-by-step guide to assembly language programming.","translation":"అసెంబ్లీ భాషా ప్రోగ్రామింగ్కు సంబంధించిన దశల వారీ మార్గదర్శకాన్ని ఈ పుస్తకం అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Assembly language is often used for low-level system programming.","translation":"అసెంబ్లీ భాషను తరచుగా తక్కువ-స్థాయి సిస్టమ్ ప్రోగ్రామింగ్ కోసం ఉపయోగిస్తారు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Understanding memory addressing is crucial in assembly language.","translation":"అసెంబ్లీ భాషలో మెమరీ చిరునామాను అర్థం చేసుకోవడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker combines the object files into an executable program.","translation":"అసెంబ్లీ భాషలో మెమరీ చిరునామాను అర్థం చేసుకోవడం చాలా ముఖ్యం.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"This chapter covers the basics of hexadecimal number systems.","translation":"ఈ అధ్యాయం హెక్సాడెసిమల్ సంఖ్యా వ్యవస్థల గురించి వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The CPU fetches and executes instructions from memory.","translation":"CPU మెమరీ నుండి సూచనలను తీసుకుని అమలు చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Macros can simplify repetitive code sequences.","translation":"పునరావృతమయ్యే కోడ్ సీక్వెన్స్లను స్థూల రూపాలు సరళీకృతం చేయగలవు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The stack is used for function calls and local variables.","translation":"ఫంక్షన్ కాల్స్ మరియు లోకల్ వేరియబుల్స్ కోసం స్టాక్ ఉపయోగించబడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book explains how to use the debugger effectively.","translation":"డీబగ్గర్ను సమర్థవంతంగా ఎలా ఉపయోగించాలో పుస్తకం వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The author provides many practical examples.","translation":"రచయిత అనేక ఆచరణాత్మక ఉదాహరణలను అందిస్తాడు.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book is a valuable resource for learning assembly language.","translation":"అసెంబ్లీ భాషను నేర్చుకోవడానికి ఈ పుస్తకం ఒక విలువైన వనరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book covers topics such as memory management and interrupts.","translation":"పుస్తకం మెమరీ నిర్వహణ మరియు అంతరాయాలు వంటి అంశాలను కవర్ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book is well-organized and easy to follow.","translation":"పుస్తకం బాగా నిర్వహించబడింది మరియు అనుసరించడానికి సులభం.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The book is suitable for both beginners and experienced programmers.","translation":"ఈ పుస్తకం ప్రారంభకులకు మరియు అనుభవజ్ఞులైన ప్రోగ్రామర్లకు అనుకూలంగా ఉంటుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book explains the differences between real mode and protected mode.","translation":"నిజమైన మోడ్ మరియు రక్షిత మోడ్ల మధ్య తేడాలను పుస్తకం వివరిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book provides a detailed explanation of the x86 architecture.","translation":"x86 ఆర్కిటెక్చర్ గురించి పుస్తకం వివరణాత్మక వివరణను అందిస్తుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The book teaches how to write efficient assembly code.","translation":"సమర్థవంతమైన అసెంబ్లీ కోడ్ను ఎలా రాయాలో పుస్తకం బోధిస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book includes examples for both DOS and Linux.","translation":"పుస్తకంలో DOS మరియు Linux రెండింటికీ ఉదాహరణలు ఉన్నాయి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The book is a comprehensive guide to assembly language programming.","translation":"అసెంబ్లీ భాషా ప్రోగ్రామింగ్కు సంబంధించిన సమగ్ర మార్గదర్శకం ఈ పుస్తకం.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"The book helps you understand the inner workings of a computer.","translation":"కంప్యూటర్ లోపలి పనితీరును అర్థం చేసుకోవడానికి ఈ పుస్తకం మీకు సహాయపడుతుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"SUB performs a subtraction without borrow, where the source is subtracted from the destination, and the result replaces the destination.","translation":"SUB అనేది బారో లేకుండా తీసివేస్తుంది, ఇక్కడ సోర్స్ గమ్యం నుండి తీసివేయబడుతుంది మరియు ఫలితం గమ్యాన్ని భర్తీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"If the result is negative, the Carry flag is set.","translation":"ఫలితం ప్రతికూలంగా ఉంటే, క్యారీ ఫ్లాగ్ సెట్ చేయబడుతుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Multiple-precision subtraction can be performed by following SUB with SBB (Subtract with Borrow) which takes the Carry flag into account as a borrow.","translation":"SUB ని SBB (బారోతో తీసివేయండి)తో అనుసరించడం ద్వారా బహుళ-ఖచ్చితత్వ తీసివేతను నిర్వహించవచ్చు, ఇది బారోగా క్యారీ ఫ్లాగ్ను పరిగణనలోకి తీసుకుంటుంది.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"XCHG exchanges the contents of its two operands.","translation":"XCHG దాని రెండు ఆపరేండ్ల కంటెంట్లను మార్పిడి చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"This is why there is no form of XCHG for identical operands; that is, XCHG AX,AX is not a legal form since exchanging a register with itself makes no logical sense.","translation":"అందుకే ఒకే ఆపరేండ్ల కోసం XCHG రూపం లేదు; అంటే, XCHG AX,AX అనేది చట్టబద్ధమైన రూపం కాదు, ఎందుకంటే రిజిస్టర్ను దానితో మార్చుకోవడం తార్కిక అర్ధాన్ని కలిగించదు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Exchanging an operand with AX may be accomplished with a single-byte opcode, saving fetch time and code space.","translation":"ఒక ఆపరేండ్ను AXతో మార్చుకోవడం ఒకే-బైట్ ఆప్కోడ్తో సాధించవచ్చు, ఇది ఫెచ్ సమయం మరియు కోడ్ స్థలాన్ని ఆదా చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"All good assemblers recognize these cases and optimize for them, but if you are hand-assembling INLINE statements for some high-level language, keep the single-byte special cases in mind.","translation":"అన్ని మంచి అసెంబ్లర్లు ఈ కేసులను గుర్తిస్తాయి మరియు వాటి కోసం ఆప్టిమైజ్ చేస్తాయి, అయితే మీరు కొన్ని హై-లెవెల్ భాష కోసం INLINE స్టేట్మెంట్లను చేతితో అసెంబ్లింగ్ చేస్తుంటే, ఒకే-బైట్ ప్రత్యేక కేసులను గుర్తుంచుకోండి.","target_lang":"te","domain":"technical","complexity":"complex"} | |
| {"en":"XOR performs the exclusive OR logical operation between its two operands.","translation":"XOR దాని రెండు ఆపరేండ్ల మధ్య ప్రత్యేకమైన లేదా తార్కిక ఆపరేషన్ను నిర్వహిస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Once the operation is complete, the result replaces the destination operand.","translation":"ఆపరేషన్ పూర్తయిన తర్వాత, ఫలితం గమ్యస్థాన ఆపరేండ్ను భర్తీ చేస్తుంది.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"XOR is performed on a bit-by-bit basis, such that bit 0 of the source is XORed with bit 0 of the destination, bit 1 of the source is XORed with bit 1 of the destination, and so on.","translation":"XOR అనేది బిట్-ద్వారా-బిట్ ప్రాతిపదికన నిర్వహించబడుతుంది, తద్వారా సోర్స్ యొక్క బిట్ 0 గమ్యం యొక్క బిట్ 0తో XOR చేయబడుతుంది, సోర్స్ యొక్క బిట్ 1 గమ్యం యొక్క బిట్ 1తో XOR చేయబడుతుంది మరియు మొదలైనవి.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The XOR operation yields a 1 if the operands are different, and a 0 if the operands are the same.","translation":"ఆపరేండ్లు భిన్నంగా ఉంటే XOR ఆపరేషన్ 1ని ఇస్తుంది మరియు ఆపరేండ్లు ఒకే విధంగా ఉంటే 0ని ఇస్తుంది.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"Note that the operation makes the Auxiliary carry flag undefined.","translation":"ఆపరేషన్ సహాయక క్యారీ ఫ్లాగ్ను నిర్వచించబడకుండా చేస్తుందని గమనించండి.","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"Where allowed, segment assumptions can be overridden with the segment override prefixes.","translation":"అనుమతించబడిన చోట, సెగ్మెంట్ ఊహలను సెగ్మెంట్ ఓవర్రైడ్ ఉపసర్గలతో భర్తీ చేయవచ్చు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"For example: mov ES:[BX],AX","translation":"ఉదాహరణకు: mov ES:[BX],AX","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"When the offset is specified in BX, SI, or DI, the assumed segment register is DS.","translation":"ఆఫ్సెట్ BX, SI లేదా DIలో పేర్కొనబడినప్పుడు, ఊహించిన సెగ్మెంట్ రిజిస్టర్ DS.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"When the offset is specified in SP, the assumed segment register is SS. CANNOT BE OVERRIDDEN.","translation":"ఆఫ్సెట్ SPలో పేర్కొనబడినప్పుడు, ఊహించిన సెగ్మెంట్ రిజిస్టర్ SS. భర్తీ చేయలేరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"For string instruction LODS, the assumed segment is DS and the assumed offset is SI. CANNOT BE OVERRIDDEN.","translation":"స్ట్రింగ్ సూచన LODS కోసం, ఊహించిన సెగ్మెంట్ DS మరియు ఊహించిన ఆఫ్సెట్ SI. భర్తీ చేయలేరు.","target_lang":"te","domain":"technical","complexity":"moderate"} | |
| {"en":"The CD-ROM included with Assembly Language Step-by-Step, Second Edition includes the following items:","translation":"అసెంబ్లీ లాంగ్వేజ్ స్టెప్-బై-స్టెప్, సెకండ్ ఎడిషన్తో చేర్చబడిన CD-ROMలో కింది అంశాలు ఉన్నాయి:","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"The x86 NASM assembler for DOS","translation":"DOS కోసం x86 NASM అసెంబ్లర్","target_lang":"te","domain":"technical","complexity":"simple"} | |
| {"en":"All the example programs presented in the book, in source code form","translation":"పుస్తకంలో అందించబడిన అన్ని ఉదాహరణ ప్రోగ్రామ్లు, సోర్స్ కోడ్ రూపంలో","target_lang":"te","domain":"technical","complexity":"simple"} |