ml/Reversing Secrets of Reverse Engineering_indic_translation.jsonl

{"en":"The book provides knowledge and techniques to allow anyone with a decent understanding of software to do just that.","translation":"സോഫ്റ്റ്‌വെയറിനെക്കുറിച്ച് നല്ല ധാരണയുള്ള ആർക്കും ഇത് ചെയ്യാൻ കഴിയുന്ന അറിവും സാങ്കേതിക വിദ്യകളും ഈ പുസ്തകം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"We should develop a solid understanding of low-level software.","translation":"നമ്മൾ കുറഞ്ഞ നിലയിലുള്ള സോഫ്റ്റ്‌വെയറിനെക്കുറിച്ച് നല്ല ധാരണ ഉണ്ടാക്കണം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Learn techniques that will allow us to easily dig into any program’s binaries and retrieve information.","translation":"ഏത് പ്രോഗ്രാമിന്റെയും ബൈനറികളിലേക്ക് എളുപ്പത്തിൽ കടന്നുചെന്ന് വിവരങ്ങൾ വീണ്ടെടുക്കാൻ സഹായിക്കുന്ന സാങ്കേതിക വിദ്യകൾ പഠിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Not sure why a system behaves the way it does and no one else has the answers?","translation":"ഒരു സിസ്റ്റം എന്തുകൊണ്ടാണ് ഇങ്ങനെ പ്രവർത്തിക്കുന്നതെന്നും മറ്റാർക്കും ഇതിന് ഉത്തരമില്ലെന്നും ഉറപ്പില്ലേ?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Dig into it on your own and find out.","translation":"സ്വന്തമായി അതിലേക്ക് ഇറങ്ങിച്ചെന്ന് കണ്ടെത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This book is to teach and demonstrate reverse engineering techniques.","translation":"റിവേഴ്സ് എഞ്ചിനിയറിംഗ് ടെക്നിക്കുകൾ പഠിപ്പിക്കാനും, പ്രകടമാക്കാനുമുള്ളതാണ് ഈ പുസ്തകം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Reverse engineering is a process where an engineered artifact is deconstructed.","translation":"റിവേഴ്സ് എഞ്ചിനിയറിംഗ് എന്നത് ഒരു എഞ്ചിനീയറിംഗ് ഉൽപ്പന്നം വിഘടിപ്പിക്കുന്ന പ്രക്രിയയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This book deals specifically with binary reverse engineering.","translation":"ഈ പുസ്തകം പ്രധാനമായും ബൈനറി റിവേഴ്സ് എഞ്ചിനിയറിംഗുമായി ബന്ധപ്പെട്ടതാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Binary reverse engineering techniques aim at extracting valuable information from programs.","translation":"പ്രോഗ്രാമുകളിൽ നിന്ന് വിലപ്പെട്ട വിവരങ്ങൾ വേർതിരിച്ചെടുക്കുക എന്നതാണ് ബൈനറി റിവേഴ്സ് എഞ്ചിനിയറിംഗ് ടെക്നിക്കുകളുടെ ലക്ഷ്യം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This book explains this process and why things work this way.","translation":"ഈ പ്രക്രിയയും കാര്യങ്ങൾ എന്തുകൊണ്ട് ഇങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതും ഈ പുസ്തകം വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Most people get a bit anxious when they try to imagine trying to extract meaningful information from an executable binary.","translation":"ഒരു എക്സിക്യൂട്ടബിൾ ബൈനറിയിൽ നിന്ന് അർത്ഥവത്തായ വിവരങ്ങൾ വേർതിരിച്ചെടുക്കാൻ ശ്രമിക്കുമ്പോൾ മിക്ക ആളുകളും അൽപ്പം ഉത്കണ്ഠാകുലരാകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Binary reverse engineering works, and it is not as difficult as you might think.","translation":"ബൈനറി റിവേഴ്സ് എഞ്ചിനിയറിംഗ് പ്രവർത്തിക്കുന്നു, നിങ്ങൾ കരുതുന്നത്ര ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല ഇത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This book focuses on reverse engineering, but it actually teaches a great deal more than that.","translation":"ഈ പുസ്തകം റിവേഴ്സ് എഞ്ചിനിയറിംഗിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു, എന്നാൽ അതിനേക്കാൾ കൂടുതൽ കാര്യങ്ങൾ ഇത് പഠിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Assembly language for IA-32 compatible processors and how to read compiler-generated assembly language code.","translation":"IA-32 അനുയോജ്യമായ പ്രോസസ്സറുകൾക്കായുള്ള അസംബ്ലി ഭാഷയും, കംപൈലർ ഉണ്ടാക്കിയ അസംബ്ലി ഭാഷാ കോഡ് എങ്ങനെ വായിക്കാമെന്നും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Operating systems internals and how to reverse engineer an operating system.","translation":"ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഇന്റേർണൽസും ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റം എങ്ങനെ റിവേഴ്സ് എഞ്ചിനീയറിംഗ് ചെയ്യാമെന്നും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Data reverse engineering: how to decipher an undocumented file-format or network protocol.","translation":"ഡാറ്റാ റിവേഴ്സ് എഞ്ചിനിയറിംഗ്: രേഖപ്പെടുത്താത്ത ഒരു ഫയൽ ഫോർമാറ്റോ നെറ്റ്‌വർക്ക് പ്രോട്ടോക്കോളോ എങ്ങനെ ഡീസൈഫർ ചെയ്യാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The legal aspects of reverse engineering: when is it legal and when is it not?","translation":"റിവേഴ്സ് എഞ്ചിനിയറിംഗിന്റെ നിയമപരമായ വശങ്ങൾ: ഇത് എപ്പോഴാണ് നിയമപരമാവുന്നത്, എപ്പോഴാണ് അല്ലാത്തത്?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"How reverse engineering is applied by crackers to defeat copy protection technologies.","translation":"കോപ്പി പ്രൊട്ടക്ഷൻ സാങ്കേതികവിദ്യകളെ പരാജയപ്പെടുത്താൻ ക്രാക്കർമാർ എങ്ങനെയാണ് റിവേഴ്സ് എഞ്ചിനിയറിംഗ് ഉപയോഗിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This book is divided into four parts.","translation":"ഈ പുസ്തകം നാല് ഭാഗങ്ങളായി തിരിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"}
{"en":"The first part provides basics that will be required in order to follow the rest of the text.","translation":"ആദ്യ ഭാഗം, ബാക്കിയുള്ളവ പിന്തുടരാൻ ആവശ്യമായ അടിസ്ഥാന കാര്യങ്ങൾ നൽകുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"}
{"en":"Reverse engineering is a critical set of techniques and tools for understanding what software is really all about.","translation":"സോഫ്റ്റ്‌വെയർ ശരിക്കും എന്താണെന്ന് മനസ്സിലാക്കാൻ സഹായിക്കുന്ന പ്രധാനപ്പെട്ട സാങ്കേതിക വിദ്യകളും ഉപകരണങ്ങളുമാണ് റിവേഴ്സ് എഞ്ചിനിയറിംഗ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The techniques of analysis, and the application of automated tools for software examination, give us a reasonable way to comprehend the complexity of the software.","translation":"വിവിധതരം സോഫ്റ്റ്‌വെയറുകൾ വിശകലനം ചെയ്യാനുള്ള സാങ്കേതിക വിദ്യകളും, ഓട്ടോമേറ്റഡ് ടൂളുകളും സോഫ്റ്റ്‌വെയറുകളുടെ സങ്കീർണ്ണത മനസ്സിലാക്കാൻ സഹായിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reverse engineering has been with us a long time.","translation":"റിവേഴ്സ് എഞ്ചിനിയറിംഗ് നമ്മോടൊപ്പം വളരെ കാലമായി ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"But, it also occurs when a developer looks at his or her own code several days after it was written.","translation":"എന്നാൽ, ഒരു ഡെവലപ്പർ സ്വന്തം കോഡ് എഴുതിയതിന് ശേഷം കുറച്ച് ദിവസങ്ങൾ കഴിഞ്ഞ് നോക്കുമ്പോഴും ഇത് സംഭവിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reverse engineering is a discovery process.","translation":"റിവേഴ്സ് എഞ്ചിനിയറിംഗ് ഒരു കണ്ടെത്തൽ പ്രക്രിയയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"When we take a fresh look at code, whether developed by ourselves or others, we examine and we learn and we see things we may not expect.","translation":"നമ്മൾ തന്നെ ഉണ്ടാക്കിയതോ മറ്റുള്ളവർ ഉണ്ടാക്കിയതോ ആയ കോഡുകൾ പുതിയരീതിയിൽ പരിശോധിക്കുമ്പോൾ, നമ്മൾ പഠിക്കുകയും പ്രതീക്ഷിക്കാത്ത പലതും കാണുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"There is now increasing interest in binary Reversing, the principal focus of this book, to support platform migration, interoperability, malware detection, and problem determination.","translation":"പ്ലാറ്റ്‌ഫോം മൈഗ്രേഷൻ, ഇന്ററോപ്പറബിലിറ്റി, മാൽവെയർ കണ്ടെത്തൽ, പ്രശ്‌നങ്ങൾ തിരിച്ചറിയൽ എന്നിവയെ പിന്തുണയ്ക്കുന്ന ഈ പുസ്തകത്തിന്റെ പ്രധാന വിഷയമായ ബൈനറി റിവേഴ്സിംഗിൽ ഇപ്പോൾ താൽപര്യം വർദ്ധിച്ചു വരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"However, reverse engineering technologies are of value in many ways to producers and consumers of software along the supply chain.","translation":"എങ്കിലും, വിതരണ ശൃംഖലയിലുടനീളമുള്ള സോഫ്റ്റ്‌വെയർ നിർമ്മാതാക്കൾക്കും ഉപഭോക്താക്കൾക്കും റിവേഴ്സ് എഞ്ചിനിയറിംഗ് സാങ്കേതികവിദ്യകൾ പല രീതിയിലും വിലപ്പെട്ടതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The tool is not inherently good or bad.","translation":"ഈ ഉപകരണം നല്ലതോ ചീത്തയോ അല്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The issue is the use to which the tool is put.","translation":"ഈ ഉപകരണം എങ്ങനെ ഉപയോഗിക്കുന്നു എന്നതാണ് പ്രശ്നം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Reverse engineering is particularly useful in modern software analysis for a wide variety of purposes.","translation":"ആധുനിക സോഫ്റ്റ്‌വെയർ വിശകലനത്തിൽ വിവിധ ആവശ്യങ്ങൾക്കായി റിവേഴ്സ് എഞ്ചിനിയറിംഗ് വളരെ ഉപയോഗപ്രദമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Finding malicious code.","translation":"ദോഷകരമായ കോഡ് കണ്ടെത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Many virus and malware detection techniques use reverse engineering to understand how abhorrent code is structured and functions.","translation":"വൈറസ്, മാൽവെയർ എന്നിവ കണ്ടെത്താനുള്ള പല സാങ്കേതിക വിദ്യകളും, മോശമായ കോഡിന്റെ ഘടനയും പ്രവർത്തനവും മനസ്സിലാക്കാൻ റിവേഴ്സ് എഞ്ചിനിയറിംഗ് ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Discovering unexpected flaws and faults.","translation":"പ്രതീക്ഷിക്കാത്ത കുറവുകളും തെറ്റുകളും കണ്ടെത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Reverse engineering can help identify flaws and faults before they become mission-critical software failures.","translation":"പ്രധാന സോഫ്റ്റ്‌വെയർ പരാജയങ്ങളാകുന്നതിനുമുമ്പ്, കുറവുകളും തെറ്റുകളും തിരിച്ചറിയാൻ റിവേഴ്സ് എഞ്ചിനിയറിംഗിന് കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Finding the use of others’ code.","translation":"മറ്റുള്ളവരുടെ കോഡിന്റെ ഉപയോഗം കണ്ടെത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Reverse engineering techniques can be used to detect the presence or absence of software elements of concern.","translation":"ആവശ്യമുള്ള സോഫ്റ്റ്‌വെയർ ഘടകങ്ങളുടെ സാന്നിധ്യമോ, അല്ലെങ്കിൽ ഇല്ലായെന്നോ കണ്ടെത്താൻ റിവേഴ്സ് എഞ്ചിനിയറിംഗ് സാങ്കേതിക വിദ്യകൾ ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Learning from others’ products of a different domain or purpose.","translation":"മറ്റുള്ളവരുടെ, വ്യത്യസ്ത മേഖലയിലുള്ള ഉൽപ്പന്നങ്ങളിൽ നിന്ന് പഠിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reverse engineering techniques can enable the study of advanced software approaches and allow new students to explore the products of masters.","translation":"നവീനമായ സോഫ്റ്റ്‌വെയർ സമീപനങ്ങളെക്കുറിച്ച് പഠിക്കാനും, പുതിയ വിദ്യാർത്ഥികൾക്ക് വിദഗ്ദ്ധരുടെ ഉൽപ്പന്നങ്ങൾ പര്യവേക്ഷണം ചെയ്യാനും റിവേഴ്സ് എഞ്ചിനിയറിംഗ് സാങ്കേതിക വിദ്യകൾ സഹായിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Many Web sites have been built by seeing what other Web sites have done.","translation":"മറ്റുള്ള വെബ്‌സൈറ്റുകൾ എന്താണ് ചെയ്തതെന്ന് കണ്ടാണ് പല വെബ്‌സൈറ്റുകളും നിർമ്മിച്ചിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Modules are simply binary files that contain isolated areas of a program’s executable.","translation":"മോഡ്യൂളുകൾ എന്നത് ഒരു പ്രോഗ്രാമിന്റെ എക്സിക്യൂട്ടബിളിന്റെ ഒറ്റപ്പെട്ട ഭാഗങ്ങൾ അടങ്ങിയ ബൈനറി ഫയലുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"There are two basic types of modules that can be combined together to make a program: static libraries and dynamic libraries.","translation":"ഒരു പ്രോഗ്രാം ഉണ്ടാക്കാൻ ഉപയോഗിക്കാവുന്ന രണ്ട് അടിസ്ഥാന തരം മോഡ്യൂളുകൾ ഉണ്ട്: സ്റ്റാറ്റിക് ലൈബ്രറികളും, ഡൈനാമിക് ലൈബ്രറികളും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Static libraries make up a group of source-code files that are built together and represent a certain component of a program.","translation":"ഒരു പ്രോഗ്രാമിന്റെ ചില ഘടകങ്ങളെ പ്രതിനിധീകരിക്കുന്ന, ഒരുമിച്ച് നിർമ്മിച്ച സോഴ്സ്-കോഡ് ഫയലുകളുടെ കൂട്ടമാണ് സ്റ്റാറ്റിക് ലൈബ്രറികൾ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Dynamic libraries are similar to static libraries, except that they are not embedded into the program.","translation":"ഡൈനാമിക് ലൈബ്രറികൾ സ്റ്റാറ്റിക് ലൈബ്രറികൾക്ക് സമാനമാണ്, എന്നാൽ അവ പ്രോഗ്രാമിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"A dynamic library allows for upgrading individual components in a program without updating the entire program.","translation":"ഒരു പ്രോഗ്രാമിന്റെ മുഴുവൻ ഭാഗവും അപ്‌ഡേറ്റ് ചെയ്യാതെ തന്നെ, അതിലെ വ്യക്തിഗത ഘടകങ്ങൾ അപ്‌ഗ്രേഡ് ചെയ്യാൻ ഒരു ഡൈനാമിക് ലൈബ്രറി അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Procedures can optionally receive input data from the caller and return data to the caller.","translation":"നടപടിക്രമങ്ങൾക്ക്, ആവശ്യമെങ്കിൽ, കോളറിൽ നിന്ന് ഇൻപുട്ട് ഡാറ്റ സ്വീകരിക്കാനും കോളറിലേക്ക് ഡാറ്റ തിരികെ നൽകാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Designing a program using objects is an entirely different process than the process of designing a regular procedure-based program.","translation":"ഒബ്ജക്റ്റുകൾ ഉപയോഗിച്ച് ഒരു പ്രോഗ്രാം രൂപകൽപ്പന ചെയ്യുന്നത്, സാധാരണ നടപടിക്രമങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ള പ്രോഗ്രാം രൂപകൽപ്പനയിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"OOD methodology defines an object as a program component that has both data and code associated with it.","translation":"OOD രീതിശാസ്ത്രം ഒരു ഒബ്ജക്റ്റിനെ ഡാറ്റയും കോഡും ഉൾക്കൊള്ളുന്ന ഒരു പ്രോഗ്രാം ഘടകമായി നിർവചിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Clients are other components in the program that require the services of the object but are not interested in any of its implementation details.","translation":"ക്ലയന്റുകൾ എന്നത് ഒബ്ജക്റ്റിന്റെ സേവനങ്ങൾ ആവശ്യമുള്ള, എന്നാൽ അതിന്റെ നടപ്പാക്കൽ വിശദാംശങ്ങളിൽ താൽപ്പര്യമില്ലാത്ത പ്രോഗ്രാമിലെ മറ്റ് ഘടകങ്ങളാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Beyond the mere division of a program into objects, most object-oriented programming languages provide an additional feature called inheritance.","translation":"ഒരു പ്രോഗ്രാമിനെ ഒബ്ജക്റ്റുകളായി വിഭജിക്കുന്നതിനപ്പുറം, ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഇൻഹെറിറ്റൻസ് എന്ന അധിക സവിശേഷത നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The idea is that the interface stays the same, so the client using the object doesn’t have to know anything about the specific object type it is dealing with.","translation":"ഇന്റർഫേസ് അതേപടി നിലനിൽക്കുന്നു എന്നതാണ് ഇതിലെ ആശയം, അതിനാൽ ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്ന ക്ലയിന്റിന്, അത് കൈകാര്യം ചെയ്യുന്ന ഒബ്ജക്റ്റിന്റെ തരം എന്താണെന്ന് അറിയേണ്ടതില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This concept is called polymorphism.","translation":"ഈ ആശയം പോളിമോർഫിസം എന്ന് അറിയപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"A program deals with data.","translation":"ഒരു പ്രോഗ്രാം ഡാറ്റയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"High-level languages tend to isolate software developers from the details surrounding data management at the system level.","translation":"സിസ്റ്റം തലത്തിലുള്ള ഡാറ്റാ മാനേജ്മെന്റുമായി ബന്ധപ്പെട്ട വിശദാംശങ്ങളിൽ നിന്ന് സോഫ്റ്റ്‌വെയർ ഡെവലപ്പർമാരെ ഉയർന്ന തലത്തിലുള്ള ഭാഷകൾ ഒറ്റപ്പെടുത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For a software developer, the key to managing and storing data is usually named variables.","translation":"ഒരു സോഫ്റ്റ്‌വെയർ ഡെവലപ്പറെ സംബന്ധിച്ചിടത്തോളം, ഡാറ്റ കൈകാര്യം ചെയ്യുകയും സംഭരിക്കുകയും ചെയ്യുന്നതിനുള്ള പ്രധാന മാർഗ്ഗം സാധാരണയായി വേരിയബിളുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"User-defined data structures are simple constructs that represent a group of data fields, each with its own type.","translation":"ഉപയോക്താവ് നിർവചിച്ച ഡാറ്റാ ഘടനകൾ, ഓരോന്നിനും അതിൻ്റേതായ തരങ്ങളുള്ള ഡാറ്റാ ഫീൽഡുകളുടെ ഒരു ഗ്രൂപ്പിനെ പ്രതിനിധീകരിക്കുന്ന ലളിതമായ ഘടനകളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Properly identifying such data structures and deciphering their contents is critical for achieving program comprehension.","translation":"അത്തരം ഡാറ്റാ ഘടനകളെ ശരിയായി തിരിച്ചറിയുകയും, അവയുടെ ഉള്ളടക്കം മനസ്സിലാക്കുകയും ചെയ്യുന്നത് പ്രോഗ്രാം മനസ്സിലാക്കുന്നതിന് നിർണായകമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Most of these generic data structures represent lists of items.","translation":"ഈ പൊതുവായ ഡാറ്റാ ഘടനകളിൽ മിക്കതും, ഇനങ്ങളുടെ ലിസ്റ്റുകളെ പ്രതിനിധീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Arrays are the most basic and intuitive list layout.","translation":"അറേകൾ ഏറ്റവും അടിസ്ഥാനപരവും അവബോധജന്യവുമായ ലിസ്റ്റ് ലേഔട്ടാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"In a linked list, each item is given its own memory space and can be placed anywhere in memory.","translation":"ഒരു ലിങ്ക്ഡ് ലിസ്റ്റിൽ, ഓരോ ഇനത്തിനും അതിൻ്റേതായ മെമ്മറി ഇടം നൽകിയിരിക്കുന്നു, കൂടാതെ മെമ്മറിയിൽ എവിടെയും സ്ഥാപിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reversing can be incredibly useful to software developers.","translation":"സോഫ്റ്റ്‌വെയർ ഡെവലപ്പർമാർക്ക് റിവേഴ്സിംഗ് വളരെ ഉപയോഗപ്രദമാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For instance, software developers can employ reversing techniques to discover how to interoperate with undocumented or partially documented software.","translation":"ഉദാഹരണത്തിന്, രേഖപ്പെടുത്താത്തതോ ഭാഗികമായി രേഖപ്പെടുത്തിയതോ ആയ സോഫ്റ്റ്‌വെയറുമായി എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് കണ്ടെത്താൻ സോഫ്റ്റ്‌വെയർ ഡെവലപ്പർമാർക്ക് റിവേഴ്സിംഗ് ടെക്നിക്കുകൾ ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In other cases, reversing can be used to determine the quality of third-party code, such as a code library or even an operating system.","translation":"മറ്റ് ചില സന്ദർഭങ്ങളിൽ, ഒരു കോഡ് ലൈബ്രറി അല്ലെങ്കിൽ ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പോലുള്ള മൂന്നാം കക്ഷി കോഡിന്റെ ഗുണനിലവാരം നിർണ്ണയിക്കാൻ റിവേഴ്സിംഗ് ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Finally, it is sometimes possible to use reversing techniques for extracting valuable information from a competitor’s product for the purpose of improving your own technologies.","translation":"അവസാനമായി, നിങ്ങളുടെ സ്വന്തം സാങ്കേതികവിദ്യകൾ മെച്ചപ്പെടുത്തുന്നതിനായി ഒരു എതിരാളിയുടെ ഉൽപ്പന്നത്തിൽ നിന്ന് വിലപ്പെട്ട വിവരങ്ങൾ വേർതിരിച്ചെടുക്കാൻ റിവേഴ്സിംഗ് ടെക്നിക്കുകൾ ഉപയോഗിക്കാൻ ചിലപ്പോൾ സാധിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Interoperability is where most software engineers can benefit from reversing almost daily.","translation":"ഇന്ററോപ്പറബിലിറ്റി എന്നത് മിക്ക സോഫ്റ്റ്‌വെയർ എഞ്ചിനീയർമാർക്കും ദിവസവും റിവേഴ്സിംഗിൽ നിന്ന് പ്രയോജനം നേടാൻ കഴിയുന്ന ഒരിടമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"When working with a proprietary software library or operating system API, documentation is almost always insufficient.","translation":"ഒരു പ്രൊപ്രൈറ്ററി സോഫ്റ്റ്‌വെയർ ലൈബ്രറിയോ അല്ലെങ്കിൽ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം API-യോ ഉപയോഗിക്കുമ്പോൾ, ഡോക്യുമെന്റേഷൻ മിക്കവാറും മതിയാകില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Regardless of how much trouble the library vendor has taken to ensure that all possible cases are covered in the documentation, users almost always find themselves scratching their heads with unanswered questions.","translation":"എല്ലാ സാധ്യതകളുമുള്ള കേസുകളും ഡോക്യുമെന്റേഷനിൽ ഉൾപ്പെടുത്താൻ ലൈബ്രറി വെണ്ടർ എത്ര ശ്രമിച്ചാലും, ഉപയോക്താക്കൾക്ക് മിക്കപ്പോഴും ഉത്തരം കിട്ടാത്ത ചോദ്യങ്ങളുമായി ആശയക്കുഴപ്പമുണ്ടാകാറുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Most developers will either be persistent and keep trying to somehow get things to work, or contact the vendor for answers.","translation":"മിക്ക ഡെവലപ്പർമാരും കാര്യങ്ങൾ എങ്ങനെയും പ്രവർത്തിപ്പിക്കാൻ ശ്രമിക്കും, അല്ലെങ്കിൽ ഉത്തരങ്ങൾക്കായി വെണ്ടറുമായി ബന്ധപ്പെടും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"On the other hand, those with reversing skills will often find it remarkably easy to deal with such situations.","translation":"മറുവശത്ത്, റിവേഴ്സിംഗ് കഴിവുകളുള്ളവർക്ക് ഇത്തരം സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നത് വളരെ എളുപ്പമാണെന്ന് കാണാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Using reversing it is possible to resolve many of these problems in very little time and with a relatively small effort.","translation":"റിവേഴ്സിംഗ് ഉപയോഗിച്ച് വളരെ കുറഞ്ഞ സമയത്തിനുള്ളിൽ താരതമ്യേന ചെറിയ പ്രയത്നത്തിലൂടെ ഈ പ്രശ്നങ്ങളിൽ പലതും പരിഹരിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Software tends to be more complex than most products, and so reversing an entire software product in order to create a competing product just doesn’t make any sense.","translation":"മിക്ക ഉൽപ്പന്നങ്ങളെക്കാളും സോഫ്റ്റ്‌വെയർ കൂടുതൽ സങ്കീർണ്ണമാണ്, അതിനാൽ ഒരു മത്സരാത്മക ഉൽപ്പന്നം ഉണ്ടാക്കുന്നതിന് ഒരു സോഫ്റ്റ്‌വെയർ ഉൽപ്പന്നം മുഴുവനായും റിവേഴ്സ് ചെയ്യുന്നത് അർത്ഥശൂന്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It is usually much easier to design and develop a product from scratch, or simply license the more complex components from a third party rather than develop them in-house.","translation":"ഒരു ഉൽപ്പന്നം ആദ്യം മുതൽ രൂപകൽപ്പന ചെയ്യുകയും വികസിപ്പിക്കുകയും ചെയ്യുന്നത് സാധാരണയായി വളരെ എളുപ്പമാണ്, അല്ലെങ്കിൽ കൂടുതൽ സങ്കീർണ്ണമായ ഘടകങ്ങൾ സ്വന്തമായി വികസിപ്പിക്കുന്നതിനുപകരം മൂന്നാം കക്ഷിയിൽ നിന്ന് ലൈസൻസ് എടുക്കുന്നതാണ് നല്ലത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In the software industry, even if a competitor has an unpatented technology, it would never make sense to reverse engineer their entire product.","translation":"സോഫ്റ്റ്‌വെയർ വ്യവസായത്തിൽ, ഒരു എതിരാളിക്ക് പേറ്റൻ്റ് ലഭിക്കാത്ത സാങ്കേതികവിദ്യയുണ്ടെങ്കിൽ പോലും, അവരുടെ മുഴുവൻ ഉൽപ്പന്നവും റിവേഴ്സ് എഞ്ചിനീയറിംഗ് ചെയ്യുന്നത് അർത്ഥമുണ്ടാക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It is almost always easier to independently develop your own software.","translation":"സ്വന്തമായി സോഫ്റ്റ്‌വെയർ വികസിപ്പിക്കുന്നത് മിക്കവാറും എപ്പോഴും എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The exception is highly complex or unique designs/algorithms that are very difficult or costly to develop.","translation":"വളരെ സങ്കീർണ്ണമായ അല്ലെങ്കിൽ അതുല്യമായ ഡിസൈനുകളും/അൽഗോരിതങ്ങളും വികസിപ്പിക്കാൻ വളരെ ബുദ്ധിമുട്ടുള്ളതോ ചെലവേറിയതോ ആകുമ്പോൾ മാത്രമാണ് ഇതിന് അപവാദമുണ്ടാകുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Just as it is possible to audit a program binary to evaluate its security and vulnerability, it is also possible to try and sample a program binary in order to get an estimate of the general quality of the coding practices used in the program.","translation":"ഒരു പ്രോഗ്രാമിന്റെ സുരക്ഷയും സാധ്യതയും വിലയിരുത്തുന്നതിന് ഒരു പ്രോഗ്രാം ബൈനറി ഓഡിറ്റ് ചെയ്യാൻ കഴിയുന്നതുപോലെ, പ്രോഗ്രാമിൽ ഉപയോഗിക്കുന്ന കോഡിംഗ് രീതികളുടെ പൊതുവായ ഗുണനിലവാരം കണക്കാക്കാൻ ഒരു പ്രോഗ്രാം ബൈനറി സാമ്പിൾ ചെയ്യാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Software vendors that don’t publish their software’s source code are essentially asking their customers to “just trust them.”","translation":"സോഫ്റ്റ്‌വെയറിന്റെ സോഴ്സ് കോഡ് പ്രസിദ്ധീകരിക്കാത്ത സോഫ്റ്റ്‌വെയർ വെണ്ടർമാർ, ഉപഭോക്താക്കളോട് “അവരെ വിശ്വസിക്കാൻ” ആവശ്യപ്പെടുകയാണ് ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It’s like buying a used car where you just can’t pop up the hood.","translation":"നിങ്ങൾക്ക് ഹുഡ് തുറക്കാൻ കഴിയാത്ത ഒരു സെക്കൻഡ് ഹാൻഡ് കാർ വാങ്ങുന്നതുപോലെയാണിത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"You have no idea what you are really buying.","translation":"നിങ്ങൾ യഥാർത്ഥത്തിൽ എന്താണ് വാങ്ങുന്നതെന്ന് നിങ്ങൾക്ക് ഒരു രൂപവുമില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Reversing requires a solid understanding of these lower layers.","translation":"റിവേഴ്സിംഗിന് ഈ താഴ്ന്ന ലെയറുകളെക്കുറിച്ച് നല്ല ധാരണ ആവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The legal debate around reverse engineering has been going on for years.","translation":"റിവേഴ്സ് എഞ്ചിനിയറിംഗിനെക്കുറിച്ചുള്ള നിയമപരമായ സംവാദം വർഷങ്ങളായി നടക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It usually revolves around the question of what social and economic impact reverse engineering has on society as a whole.","translation":"റിവേഴ്സ് എഞ്ചിനിയറിംഗ് സമൂഹത്തിൽ മൊത്തത്തിൽ എന്ത് സാമൂഹികവും സാമ്പത്തികവുമായ സ്വാധീനം ചെലുത്തുന്നു എന്ന ചോദ്യത്തെക്കുറിച്ചാണ് ഇത് സാധാരണയായി പറയുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Always seek legal counsel before getting yourself into any high-risk reversing project.","translation":"ഏതെങ്കിലും ഉയർന്ന അപകടസാധ്യതയുള്ള റിവേഴ്സിംഗ് പ്രോജക്റ്റിൽ ഏർപ്പെടുന്നതിന് മുമ്പ് എല്ലായ്പ്പോഴും നിയമോപദേശം തേടുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Interoperability Getting two programs to communicate and interoperate is never an easy task.","translation":"പരസ്പരം പ്രവർത്തിക്കാനുള്ള രണ്ട് പ്രോഗ്രാമുകൾക്ക് ആശയവിനിമയം നടത്താനും പ്രവർത്തിക്കാനും കഴിയുന്നത് ഒരിക്കലും എളുപ്പമുള്ള കാര്യമല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"When a software developer wishes to develop software that communicates with a component developed by another company, there are large amounts of information that must be exposed by the other party regarding the interfaces.","translation":"ഒരു സോഫ്റ്റ്‌വെയർ ഡെവലപ്പർ മറ്റൊരു കമ്പനി വികസിപ്പിച്ച ഒരു ഘടകവുമായി ആശയവിനിമയം നടത്തുന്ന സോഫ്റ്റ്‌വെയർ വികസിപ്പിക്കാൻ ആഗ്രഹിക്കുമ്പോൾ, ഇന്റർഫേസുകളെക്കുറിച്ച് മറ്റ് കക്ഷികൾ വലിയ അളവിൽ വിവരങ്ങൾ വെളിപ്പെടുത്തേണ്ടതുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"For example, both Microsoft Windows and Sony Playstation are software platforms.","translation":"ഉദാഹരണത്തിന്, Microsoft Windows, Sony Playstation എന്നിവ സോഫ്റ്റ്‌വെയർ പ്ലാറ്റ്‌ഫോമുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Publishing software interfaces would also create new competition for the vendor’s own applications.","translation":"സോഫ്റ്റ്‌വെയർ ഇന്റർഫേസുകൾ പ്രസിദ്ധീകരിക്കുന്നത് വെണ്ടറുടെ സ്വന്തം ആപ്ലിക്കേഷനുകൾക്കായി പുതിയ മത്സരം സൃഷ്ടിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"When used for interoperability, reverse engineering clearly benefits society because it simplifies (or enables) the development of new and improved technologies.","translation":"പരസ്പരം പ്രവർത്തിക്കുന്നതിന് ഉപയോഗിക്കുമ്പോൾ, പുതിയതും മെച്ചപ്പെട്ടതുമായ സാങ്കേതികവിദ്യകളുടെ വികസനം ലളിതമാക്കുന്നതിനാൽ (അല്ലെങ്കിൽ പ്രാപ്തമാക്കുന്നതിനാൽ) റിവേഴ്സ് എഞ്ചിനിയറിംഗ് സമൂഹത്തിന് വ്യക്തമായ പ്രയോജനം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Opponents of reverse engineering usually claim that reversing stifles innovation because developers of new technologies have little incentive to invest in research and development if their technologies can be easily “stolen” by competitors through reverse engineering.","translation":"റിവേഴ്സ് എഞ്ചിനിയറിംഗിനെ എതിർക്കുന്നവർ സാധാരണയായി പറയുന്നത്, പുതിയ സാങ്കേതികവിദ്യകളുടെ ഡെവലപ്പർമാർക്ക് അവരുടെ സാങ്കേതികവിദ്യകൾ എതിരാളികൾക്ക് റിവേഴ്സ് എഞ്ചിനിയറിംഗിലൂടെ എളുപ്പത്തിൽ “മോഷ്ടിക്കാൻ” കഴിയുമെങ്കിൽ ഗവേഷണത്തിലും വികസനത്തിലും നിക്ഷേപം നടത്താൻ വലിയ പ്രോത്സാഹനമില്ലാത്തതിനാൽ റിവേഴ്സിംഗ് കണ്ടുപിടുത്തങ്ങളെ തടസ്സപ്പെടുത്തുന്നു എന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This brings us to the question of what exactly constitutes reverse engineering for the purpose of developing a competing product.","translation":"മത്സരാധിഷ്ഠിതമായ ഒരു ഉൽപ്പന്നം വികസിപ്പിക്കുന്നതിന് വേണ്ടി എന്താണ് യഥാർത്ഥത്തിൽ റിവേഴ്സ് എഞ്ചിനിയറിംഗ് എന്ന് ഇത് നമ്മെ ചിന്തിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The most extreme example is to directly steal code segments from a competitor’s product and embed them into your own.","translation":"ഏറ്റവും വലിയ ഉദാഹരണമാണ് ഒരു എതിരാളിയുടെ ഉൽപ്പന്നത്തിൽ നിന്ന് കോഡ് ഭാഗങ്ങൾ നേരിട്ട് മോഷ്ടിക്കുകയും അവ സ്വന്തം ഉൽപ്പന്നത്തിൽ ഉൾപ്പെടുത്തുകയും ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is a clear violation of copyright laws and is typically very easy to prove.","translation":"ഇത് പകർപ്പവകാശ നിയമങ്ങളുടെ ലംഘനമാണ്, ഇത് തെളിയിക്കാൻ സാധാരണയായി വളരെ എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"In 1990 Sega Enterprises, a well-known Japanese gaming company, released their Genesis gaming console.","translation":"1990-ൽ, അറിയപ്പെടുന്ന ജാപ്പനീസ് ഗെയിമിംഗ് കമ്പനിയായ സെഗ എന്റർപ്രൈസസ് അവരുടെ ജെനിസിസ് ഗെയിമിംഗ് കൺസോൾ പുറത്തിറക്കി.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Accolade explored the option of becoming a Sega licensee, but quickly abandoned the idea because Sega required that all games be exclusively manufactured for the Genesis console.","translation":"സെഗയുടെ ലൈസൻസിയാകാനുള്ള സാധ്യത അക്കോലേഡ് പരിശോധിച്ചു, എന്നാൽ സെഗ എല്ലാ ഗെയിമുകളും ജെനിസിസ് കൺസോളിനായി മാത്രം നിർമ്മിക്കണമെന്ന് ആവശ്യപ്പെട്ടതിനാൽ ഈ ആശയം പെട്ടെന്ന് ഉപേക്ഷിച്ചു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Accolade reverse engineered portions of the Genesis console and several of Sega’s game cartridges.","translation":"അക്കോലേഡ് ജെനിസിസ് കൺസോളിന്റെ ഭാഗങ്ങളും സെഗയുടെ നിരവധി ഗെയിം കാട്രിഡ്ജുകളും റിവേഴ്സ് എഞ്ചിനിയറിംഗ് നടത്തി.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The court eventually ruled in Accolade’s favor because Accolade’s games didn’t actually contain any of Sega’s code, and because of the public benefit resulting from Accolade’s work (by way of introducing additional competition in the market).","translation":"അക്കോലേഡിന്റെ ഗെയിമുകളിൽ സെഗയുടെ കോഡുകളൊന്നും അടങ്ങിയിട്ടില്ലാത്തതിനാലും, അക്കോലേഡിന്റെ പ്രവർത്തനത്തിന്റെ ഫലമായി പൊതുജനങ്ങൾക്ക് പ്രയോജനം ലഭിച്ചതിനാലും (വിപണിയിൽ കൂടുതൽ മത്സരം കൊണ്ടുവന്നതിലൂടെ) കോടതി ഒടുവിൽ അക്കോലേഡിന് അനുകൂലമായി വിധിച്ചു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Copyright laws aim to protect software and other intellectual property from any kind of unauthorized duplication, and so on.","translation":"ഏത് തരത്തിലുള്ള അനധികൃത പകർപ്പിൽ നിന്നും സോഫ്റ്റ്‌വെയറും മറ്റ് ബൗദ്ധിക സ്വത്തുക്കളും സംരക്ഷിക്കുക എന്നതാണ് പകർപ്പവകാശ നിയമങ്ങളുടെ ലക്ഷ്യം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Consider the decompilation of a program as an example.","translation":"ഒരു പ്രോഗ്രാമിന്റെ ഡീകംപൈലേഷൻ ഒരു ഉദാഹരണമായി പരിഗണിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"In order to decompile a program, that program must be duplicated at least once, either in memory, on disk, or both.","translation":"ഒരു പ്രോഗ്രാം ഡീകംപൈൽ ചെയ്യുന്നതിന്, ആ പ്രോഗ്രാം മെമ്മറിയിലോ, ഡിസ്‌കിലോ അല്ലെങ്കിൽ രണ്ടിലുമോ കുറഞ്ഞത് ഒരു തവണയെങ്കിലും ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"When a new technology is developed, developers are usually faced with two primary options for protecting the unique aspects of it.","translation":"ഒരു പുതിയ സാങ്കേതികവിദ്യ വികസിപ്പിക്കുമ്പോൾ, അതിന്റെ അതുല്യമായ വശങ്ങൾ സംരക്ഷിക്കുന്നതിന് സാധാരണയായി രണ്ട് പ്രധാന ഓപ്ഷനുകളാണ് ഡെവലപ്പർമാർക്ക് മുന്നിലുള്ളത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The program can be decompiled with high accuracy.","translation":"പ്രോഗ്രാം വളരെ കൃത്യതയോടെ ഡീകംപൈൽ ചെയ്യാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reversing Java classes is simpler than with native code.","translation":"നേറ്റീവ് കോഡിനേക്കാൾ ലളിതമാണ് ജാവ ക്ലാസുകൾ റിവേഴ്സ് ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is still challenging to understand undocumented source code.","translation":"രേഖപ്പെടുത്താത്ത സോഴ്സ് കോഡ് മനസ്സിലാക്കുന്നത് ഇപ്പോഴും വെല്ലുവിളിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"C# was developed by Microsoft.","translation":"C# വികസിപ്പിച്ചത് മൈക്രോസോഫ്റ്റാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"C# is a Java-like object-oriented language.","translation":"C# ഒരു ജാവ പോലുള്ള ഒബ്ജക്റ്റ് ഓറിയന്റഡ് ഭാഷയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"C# aims to overcome problems in C++.","translation":"C++ൽ ഉള്ള പ്രശ്നങ്ങളെ മറികടക്കാൻ C# ലക്ഷ്യമിടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"C# is based on using a virtual machine.","translation":"C# ഒരു വെർച്വൽ മെഷീൻ ഉപയോഗിക്കുന്നതിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"C# programs are compiled into bytecode.","translation":"C# പ്രോഗ്രാമുകൾ ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"MSIL programs run on the CLR.","translation":"MSIL പ്രോഗ്രാമുകൾ പ്രവർത്തിക്കുന്നത് CLR-ലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":".NET programs are not bound to Windows.","translation":".NET പ്രോഗ്രാമുകൾ വിൻഡോസിനു മാത്രമായി പരിമിതപ്പെടുത്തിയിട്ടില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"C# has advanced features like garbage collection.","translation":"C# ന് ഗാർബേജ് കളക്ഷൻ പോലുള്ള നൂതന സവിശേഷതകളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reversing C# programs sometimes requires learning MSIL.","translation":"ചിലപ്പോൾ C# പ്രോഗ്രാമുകൾ റിവേഴ്സ് ചെയ്യുന്നതിന് MSIL പഠിക്കേണ്ടി വരും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Developers often obfuscate their code.","translation":"ഡെവലപ്പർമാർ പലപ്പോഴും അവരുടെ കോഡ് അവ്യക്തമാക്കാറുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reversing .NET programs can be complex.","translation":".NET പ്രോഗ്രാമുകൾ റിവേഴ്സ് ചെയ്യുന്നത് സങ്കീർണ്ണമായ ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Understand how high-level constructs are implemented.","translation":"ഉയർന്ന തലത്തിലുള്ള ഘടനകൾ എങ്ങനെ നടപ്പിലാക്കുന്നു എന്ന് മനസ്സിലാക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Data management is a key difference.","translation":"ഡാറ്റാ മാനേജ്മെൻ്റ് ഒരു പ്രധാന വ്യത്യാസമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"High-level languages hide data management details.","translation":"ഉയർന്ന തലത്തിലുള്ള ഭാഷകൾ ഡാറ്റാ മാനേജ്മെൻ്റിൻ്റെ വിശദാംശങ്ങൾ മറയ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"CPUs rarely have instructions for declaring a variable.","translation":"ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ CPU-കളിൽ വളരെ കുറവാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Hardware limitations affect instruction complexity.","translation":"ഹാർഡ്‌വെയർ പരിമിതികൾ ഇൻസ്ട്രക്ഷൻ സങ്കീർണ്ണതയെ ബാധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Registers are internal processor memory.","translation":"രജിസ്റ്ററുകൾ ഇന്റേണൽ പ്രൊസസ്സർ മെമ്മറിയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The instruction will jump to the specified code address if the operands compared earlier by CMP are not equal.","translation":"CMP ഉപയോഗിച്ച് മുമ്പ് താരതമ്യം ചെയ്ത ഓപ്പറാൻഡുകൾ തുല്യമല്ലെങ്കിൽ, നിർദ്ദേശം വ്യക്തമാക്കിയ കോഡ് വിലാസത്തിലേക്ക് ജമ്പ് ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The MOV instruction is probably the most popular IA-32 instruction.","translation":"MOV നിർദ്ദേശം ഒരുപക്ഷേ ഏറ്റവും പ്രചാരമുള്ള IA-32 നിർദ്ദേശമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Operands are compared using the CMP instruction.","translation":"CMP നിർദ്ദേശം ഉപയോഗിച്ചാണ് ഓപ്പറാൻഡുകൾ താരതമ്യം ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The compiler might reverse the condition and branch if bSuccessis nonzero.","translation":"bSuccessis പൂജ്യമല്ലാത്തതാണെങ്കിൽ, കംപൈലർ അവസ്ഥ വിപരീതമാക്കുകയും ബ്രാഞ്ച് ചെയ്യുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Instructions usually consist of an opcode (operation code), and one or two operands.","translation":"നിർദ്ദേശങ്ങളിൽ സാധാരണയായി ഒരു opcode (ഓപ്പറേഷൻ കോഡ്), ഒന്നോ രണ്ടോ ഓപ്പറാൻഡുകൾ എന്നിവ അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The opcode is an instruction name such as MOV, and the operands are the “parameters” that the instruction receives.","translation":"opcode എന്നത് MOV പോലുള്ള ഒരു നിർദ്ദേശത്തിന്റെ പേരാണ്, കൂടാതെ ഓപ്പറാൻഡുകൾ നിർദ്ദേശം സ്വീകരിക്കുന്ന “പാരാമീറ്ററുകൾ” ആണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Operands represent data that is handled by the specific instruction.","translation":"നിർദ്ദിഷ്ട നിർദ്ദേശം കൈകാര്യം ചെയ്യുന്ന ഡാറ്റയെയാണ് ഓപ്പറാൻഡുകൾ പ്രതിനിധീകരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"When an operand resides in RAM, its memory address is enclosed in brackets.","translation":"ഒരു ഓപ്പറാൻഡ് RAM-ൽ സ്ഥിതി ചെയ്യുമ്പോൾ, അതിന്റെ മെമ്മറി വിലാസം ബ്രാക്കറ്റുകളിൽ ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The general instruction format looks like this: Instruction Name Destination Operand, Source Operand.","translation":"പൊതുവായ നിർദ്ദേശ ഫോർമാറ്റ് ഇപ്രകാരമാണ്: നിർദ്ദേശത്തിന്റെ പേര് ലക്ഷ്യസ്ഥാനം, ഉറവിടം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Some instructions only take one operand, whose purpose depends on the specific instruction.","translation":"ചില നിർദ്ദേശങ്ങൾ ഒരു ഓപ്പറാൻ്റ് മാത്രമേ എടുക്കൂ, അതിന്റെ ഉദ്ദേശ്യം നിർദ്ദിഷ്ട നിർദ്ദേശത്തെ ആശ്രയിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"These are popular instructions that appear everywhere in a program.","translation":"ഇവ ഒരു പ്രോഗ്രാമിൽ എല്ലായിടത്തും കാണുന്ന ജനപ്രിയ നിർദ്ദേശങ്ങളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"MOV takes two operands: a destination operand and a source operand, and simply moves data from the source to the destination.","translation":"MOV രണ്ട് ഓപ്പറാൻഡുകൾ എടുക്കുന്നു: ഒരു ലക്ഷ്യസ്ഥാന ഓപ്പറാൻഡും ഒരു സോഴ്സ് ഓപ്പറാൻഡും, കൂടാതെ ഡാറ്റയെ ഉറവിടത്തിൽ നിന്ന് ലക്ഷ്യസ്ഥാനത്തേക്ക് നീക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For basic arithmetic operations, the IA-32 instruction set includes six basic integer arithmetic instructions.","translation":"അടിസ്ഥാന ഗണിത പ്രവർത്തനങ്ങൾക്കായി, IA-32 നിർദ്ദേശ സെറ്റിൽ ആറ് അടിസ്ഥാന പൂർണ്ണസംഖ്യാ ഗണിത നിർദ്ദേശങ്ങൾ ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The AT&T Unix notation is another notation for assembly language instructions that is quite different from the Intel notation.","translation":"അസംബ്ലി ഭാഷാ നിർദ്ദേശങ്ങൾക്കുള്ള മറ്റൊരു രീതിയാണ് AT&T Unix നൊട്ടേഷൻ, ഇത് Intel നൊട്ടേഷനിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In the AT&T notation the source operand usually precedes the destination operand.","translation":"AT&T നൊട്ടേഷനിൽ, സോഴ്സ് ഓപ്പറാൻഡ് സാധാരണയായി ലക്ഷ്യസ്ഥാന ഓപ്പറാൻഡിന് മുമ്പായി വരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Conditional branches are implemented using the Jcc group of instructions.","translation":"Jcc ഗ്രൂപ്പ് നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ചാണ് വ്യവസ്ഥാപിത ബ്രാഞ്ചുകൾ നടപ്പിലാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The CALL instruction calls a function, and the RET instruction returns to the caller.","translation":"CALL നിർദ്ദേശം ഒരു ഫംഗ്ഷനെ വിളിക്കുന്നു, കൂടാതെ RET നിർദ്ദേശം കോളറിലേക്ക് മടങ്ങുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"When a function completes and needs to return to its caller, it usually invokes the RET instruction.","translation":"ഒരു ഫംഗ്ഷൻ പൂർത്തിയാകുമ്പോൾ അതിന്റെ കോളറിലേക്ക് മടങ്ങേണ്ടിവരുമ്പോൾ, അത് സാധാരണയായി RET നിർദ്ദേശം വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s have a quick look at a few short snippets of assembly language, just to make sure that you understand the basic concepts.","translation":"അടിസ്ഥാന ആശയങ്ങൾ നിങ്ങൾ മനസ്സിലാക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ, അസംബ്ലി ഭാഷയുടെ ചില ചെറിയ ഭാഗങ്ങൾ നമുക്ക് പെട്ടെന്ന് പരിശോധിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The first instruction is CMP, which compares the two operands specified.","translation":"ആദ്യത്തെ നിർദ്ദേശം CMP ആണ്, ഇത് വ്യക്തമാക്കിയ രണ്ട് ഓപ്പറാൻഡുകളെ താരതമ്യം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Optimizers have algorithms that search for such redundancies and eliminate them.","translation":"അത്തരം അധികപ്പറ്റുകൾ തിരയുകയും അവ ഇല്ലാതാക്കുകയും ചെയ്യുന്ന അൽഗോരിതങ്ങൾ ഒപ്റ്റിമൈസറുകൾക്കുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For example, programmers routinely leave static expressions inside loops, which is wasteful.","translation":"ഉദാഹരണത്തിന്, പ്രോഗ്രാമർമാർ സാധാരണയായി ലൂപ്പുകൾക്കുള്ളിൽ സ്ഥിരമായ എക്സ്പ്രഷനുകൾ ഉപേക്ഷിക്കാറുണ്ട്, ഇത് വളരെ അധികം പാഴായിപ്പോകാൻ സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"A good optimizer identifies such statements and relocates them to an area outside of the loop in order to improve on the code’s efficiency.","translation":"ഒരു നല്ല ഒപ്റ്റിമൈസർ അത്തരം പ്രസ്താവനകൾ തിരിച്ചറിയുകയും കോഡിന്റെ കാര്യക്ഷമത മെച്ചപ്പെടുത്തുന്നതിനായി ലൂപ്പിന് പുറത്തുള്ള ഒരു സ്ഥലത്തേക്ക് മാറ്റുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Optimizers can also streamline pointer arithmetic.","translation":"പോയിന്റർ ഗണിതവും ഒപ്റ്റിമൈസറുകൾക്ക് കാര്യക്ഷമമാക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The compiler’s back end is responsible for generating target-specific code.","translation":"കമ്പൈലറുടെ ബാക്ക് എൻഡ് ടാർഗെറ്റ്-നിർദ്ദിഷ്ട കോഡ് ഉണ്ടാക്കുന്നതിന് ഉത്തരവാദിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is where the intermediate representation “meets” the target-specific language.","translation":"ഇടക്കാല പ്രാതിനിധ്യം ടാർഗെറ്റ്-നിർദ്ദിഷ്ട ഭാഷയുമായി “സംഗമിക്കുന്നത്” ഇവിടെയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The code generator is responsible for the actual selection of specific assembly language instructions.","translation":"പ്രത്യേക അസംബ്ലി ഭാഷാ നിർദ്ദേശങ്ങൾ തിരഞ്ഞെടുക്കുന്നതിന് കോഡ് ജനറേറ്റർ ഉത്തരവാദിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Instruction selection is where the code from the intermediate representation is translated into platform-specific instructions.","translation":"ഇടക്കാല പ്രാതിനിധ്യത്തിൽ നിന്നുള്ള കോഡ് പ്ലാറ്റ്‌ഫോം-നിർദ്ദിഷ്ട നിർദ്ദേശങ്ങളിലേക്ക് വിവർത്തനം ചെയ്യുന്നത് ഇൻസ്ട്രക്ഷൻ സെലക്ഷനിലാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In many intermediate representations there is an unlimited number of registers available.","translation":"പല ഇടക്കാല പ്രാതിനിധ്യങ്ങളിലും, ലഭ്യമായ രജിസ്റ്ററുകളുടെ എണ്ണം പരിധിയില്ലാത്തതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The compiler must decide which variable gets placed in which register.","translation":"ഏത് വേരിയബിളാണ് ഏത് രജിസ്റ്ററിൽ സ്ഥാപിക്കേണ്ടതെന്ന് കംപൈലർ തീരുമാനിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Because most modern processors can handle multiple instructions at once, data dependencies between individual instructions become an issue.","translation":"ആധുനിക പ്രോസസ്സറുകൾക്ക് ഒരേ സമയം ഒന്നിലധികം നിർദ്ദേശങ്ങൾ കൈകാര്യം ചെയ്യാൻ കഴിയുന്നതിനാൽ, വ്യക്തിഗത നിർദ്ദേശങ്ങൾ തമ്മിലുള്ള ഡാറ്റാ ആശ്രയത്വങ്ങൾ ഒരു പ്രശ്നമായി മാറുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The end result is interleaved code.","translation":"അവസാന ഫലം ഇന്റർലീവ്ഡ് കോഡാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"A listing file is a compiler-generated text file that contains the assembly language code.","translation":"ഒരു ലിസ്റ്റിംഗ് ഫയൽ എന്നത് കംപൈലർ ഉണ്ടാക്കുന്ന ഒരു ടെക്സ്റ്റ് ഫയലാണ്, അതിൽ അസംബ്ലി ഭാഷാ കോഡ് അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Most compilers support the generation of listing files during the compilation process.","translation":"മിക്ക കംപൈലറുകളും കംപൈലേഷൻ പ്രക്രിയയിൽ ലിസ്റ്റിംഗ് ഫയലുകൾ ഉണ്ടാക്കുന്നത് പിന്തുണയ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The GNU C Compiler (GCC) and GNU C++ Compiler (G++) are popular open-source compilers.","translation":"GNU C കംപൈലറും (GCC) GNU C++ കംപൈലറും (G++) ജനപ്രിയമായ ഓപ്പൺ സോഴ്സ് കംപൈലറുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The Microsoft Optimizing Compiler is one of the most common compilers for the Windows platform.","translation":"വിൻഡോസ് പ്ലാറ്റ്‌ഫോമിനായുള്ള ഏറ്റവും സാധാരണ കംപൈലറുകളിൽ ഒന്നാണ് Microsoft Optimizing Compiler.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The Intel compiler has a good optimization stage.","translation":"ഇന്റൽ കംപൈലറിന് നല്ല ഒപ്റ്റിമൈസേഷൻ ഘട്ടമുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Execution environments are especially important to reversers.","translation":"റിവേഴ്സറുകൾക്ക് എക്സിക്യൂഷൻ എൻവയോൺമെന്റുകൾ വളരെ പ്രധാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Some software development platforms don’t produce executable machine code.","translation":"ചില സോഫ്റ്റ്‌വെയർ വികസന പ്ലാറ്റ്‌ഫോമുകൾ എക്സിക്യൂട്ടബിൾ മെഷീൻ കോഡ് ഉണ്ടാക്കുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Virtual machines are always processor-specific.","translation":"വിർച്വൽ മെഷീനുകൾ എപ്പോഴും പ്രോസസ്സർ-നിർദ്ദിഷ്ടമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Private allocations are typically used by the system for allocating stacks and heaps.","translation":"സ്വകാര്യ അലോക്കേഷനുകൾ സാധാരണയായി സ്റ്റാക്കുകളും, ഹീപ്പുകളും അനുവദിക്കുന്നതിന് സിസ്റ്റം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"HeapsMost Windows applications don’t directly call VirtualAlloc.","translation":"ഹീപ്‌സ്: വിൻഡോസ് ആപ്ലിക്കേഷനുകൾ സാധാരണയായി VirtualAlloc-നെ നേരിട്ട് വിളിക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"A heap is a data structure that enables the creation of multiple variable-sized blocks of memory within a larger block.","translation":"ഒരു വലിയ ബ്ലോക്കിനുള്ളിൽ ഒന്നിലധികം വേരിയബിൾ-സൈസ് മെമ്മറി ബ്ലോക്കുകൾ സൃഷ്ടിക്കാൻ സഹായിക്കുന്ന ഒരു ഡാറ്റാ ഘടനയാണ് ഹീപ്പ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The operating system offers its own heaps through the HeapAllocand HeapFree Win32 APIs.","translation":"HeapAlloc, HeapFree Win32 API-കളിലൂടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം അതിൻ്റേതായ ഹീപ്പുകൾ വാഗ്ദാനം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"User-mode stacks are essentially regular private allocations.","translation":"ഉപയോക്തൃ-മോഡ് സ്റ്റാക്കുകൾ പ്രധാനമായും സാധാരണ സ്വകാര്യ അലോക്കേഷനുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"ExecutablesAnother common allocation type is a mapped executable allocation.","translation":"എക്സിക്യൂട്ടബിളുകൾ: മറ്റൊരു സാധാരണ അലോക്കേഷൻ തരം ഒരു മാപ്പ് ചെയ്ത എക്സിക്യൂട്ടബിൾ അലോക്കേഷനാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Applications can create memory-mapped files and map them into their address space.","translation":"ആപ്ലിക്കേഷനുകൾക്ക് മെമ്മറി-മാപ്പ് ചെയ്ത ഫയലുകൾ ഉണ്ടാക്കാനും അവയുടെ വിലാസ സ്ഥലത്തേക്ക് മാപ്പ് ചെയ്യാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is a convenient and commonly used method for sharing memory between two or more programs.","translation":"രണ്ടോ അതിലധികമോ പ്രോഗ്രാമുകൾക്കിടയിൽ മെമ്മറി പങ്കിടുന്നതിനുള്ള സൗകര്യപ്രദവും സാധാരണയായി ഉപയോഗിക്കുന്നതുമായ രീതിയാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"VirtualAllocThis function allocates a private memory block within a user-mode address space.","translation":"VirtualAlloc: ഈ ഫംഗ്ഷൻ ഉപയോക്തൃ-മോഡ് വിലാസ സ്ഥലത്തിനുള്ളിൽ ഒരു സ്വകാര്യ മെമ്മറി ബ്ലോക്ക് അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is a low-level memory block whose size must be page-aligned.","translation":"ഇതൊരു താഴ്ന്ന നിലയിലുള്ള മെമ്മറി ബ്ലോക്കാണ്, ഇതിൻ്റെ വലുപ്പം പേജ്-അലൈൻഡ് ആയിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reserving a block means that we simply reserve the address space but don’t actually use up any memory.","translation":"ഒരു ബ്ലോക്ക് റിസർവ് ചെയ്യുക എന്നാൽ വിലാസ സ്ഥലം റിസർവ് ചെയ്യുക, എന്നാൽ മെമ്മറി ഉപയോഗിക്കില്ല എന്നാണ് അർത്ഥമാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Committing a block means that we actually allocate space for it in the system page file.","translation":"ഒരു ബ്ലോക്ക് കമ്മീറ്റ് ചെയ്യുക എന്നാൽ സിസ്റ്റം പേജ് ഫയലിൽ അതിനായി സ്ഥലം അനുവദിക്കുക എന്നാണ് അർത്ഥമാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"VirtualProtectThis function sets a memory region’s protection settings.","translation":"VirtualProtect: ഈ ഫംഗ്ഷൻ ഒരു മെമ്മറി മേഖലയുടെ പ്രൊട്ടക്ഷൻ ക്രമീകരണങ്ങൾ സജ്ജമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"VirtualQueryThis function queries the current memory block.","translation":"VirtualQuery: ഈ ഫംഗ്ഷൻ നിലവിലെ മെമ്മറി ബ്ലോക്ക് അന്വേഷിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"VirtualFreeThis function frees a private allocation block.","translation":"VirtualFree: ഈ ഫംഗ്ഷൻ ഒരു സ്വകാര്യ അലോക്കേഷൻ ബ്ലോക്ക് സ്വതന്ത്രമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"All of these APIs deal with the currently active address space.","translation":"ഈ API-കളെല്ലാം നിലവിൽ സജീവമായ വിലാസ സ്ഥലവുമായി ബന്ധപ്പെട്ടതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The Windows kernel manages objects using a centralized object manager component.","translation":"വിൻഡോസ് കേർണൽ ഒരു കേന്ദ്രീകൃത ഒബ്ജക്റ്റ് മാനേജർ ഘടകം ഉപയോഗിച്ച് ഒബ്ജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"GUI-related objects such as windows, menus, and device contexts are managed by separate object managers.","translation":"വിൻഡോകൾ, മെനുകൾ, ഉപകരണ സന്ദർഭങ്ങൾ തുടങ്ങിയ GUI-യുമായി ബന്ധപ്പെട്ട ഒബ്ജക്റ്റുകൾ പ്രത്യേക ഒബ്ജക്റ്റ് മാനേജർമാരാണ് കൈകാര്യം ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It is important to understand that under the hood all of these objects are merely data structures.","translation":"ഈ ഒബ്ജക്റ്റുകളെല്ലാം വെറും ഡാറ്റാ ഘടനകൾ മാത്രമാണെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"All objects use a standard object header that describes the basic object properties.","translation":"എല്ലാ ഒബ്ജക്റ്റുകളും അടിസ്ഥാന ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ വിവരിക്കുന്ന ഒരു സാധാരണ ഒബ്ജക്റ്റ് ശീർഷകം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In order to improve the processor’s prediction abilities, IA-32 processors employ a branch trace buffer (BTB) which records the results of the most recent branch instructions processed.","translation":"പ്രോസസ്സറിൻ്റെ പ്രവചന ശേഷി മെച്ചപ്പെടുത്തുന്നതിന്, IA-32 പ്രോസസ്സറുകൾ ഒരു ബ്രാഞ്ച് ട്രെയ്സ് ബഫർ (BTB) ഉപയോഗിക്കുന്നു, ഇത് ഏറ്റവും പുതിയ ബ്രാഞ്ച് നിർദ്ദേശങ്ങളുടെ ഫലങ്ങൾ രേഖപ്പെടുത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This way when a branch is encountered, it is searched in the BTB.","translation":"ഇപ്രകാരം ഒരു ബ്രാഞ്ച് കണ്ടെത്തുമ്പോൾ, അത് BTB-യിൽ തിരയുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"If an entry is found, the processor uses that information for predicting the branch.","translation":"ഒരു എൻട്രി കണ്ടെത്തിയാൽ, ബ്രാഞ്ച് പ്രവചിക്കാൻ പ്രോസസ്സർ ആ വിവരങ്ങൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"In this chapter, we have introduced the concept of low-level software and gone over some basic materials required for successfully reverse engineering programs.","translation":"ഈ അധ്യായത്തിൽ, ഞങ്ങൾ താഴ്ന്ന നിലയിലുള്ള സോഫ്റ്റ്‌വെയറിൻ്റെ ആശയം അവതരിപ്പിക്കുകയും പ്രോഗ്രാമുകൾ വിജയകരമായി റിവേഴ്സ് എഞ്ചിനീയറിംഗിന് ആവശ്യമായ ചില അടിസ്ഥാന കാര്യങ്ങൾ ചർച്ച ചെയ്യുകയും ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"We have covered basic high-level software concepts and how they translate into the low-level world, and introduced assembly language, which is the native language of the reversing world.","translation":"അടിസ്ഥാനപരമായ ഉയർന്ന തലത്തിലുള്ള സോഫ്റ്റ്‌വെയർ ആശയങ്ങളും അവ താഴ്ന്ന തലത്തിലേക്ക് എങ്ങനെ വിവർത്തനം ചെയ്യപ്പെടുന്നു എന്നതും ഞങ്ങൾ ഉൾപ്പെടുത്തി, റിവേഴ്സിംഗ് ലോകത്തിലെ മാതൃഭാഷയായ അസംബ്ലി ഭാഷയും അവതരിപ്പിച്ചു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Additionally, we have covered some more hard core low-level topics that often affect the reverse-engineering process, such as compilers and execution environments.","translation":"കൂടാതെ, കംപൈലറുകൾ, എക്സിക്യൂഷൻ എൻവയോൺമെന്റുകൾ എന്നിവപോലെയുള്ള, റിവേഴ്സ് എഞ്ചിനീയറിംഗ് പ്രക്രിയയെ ബാധിക്കുന്ന കൂടുതൽ കഠിനമായ ചില താഴ്ന്ന തലത്തിലുള്ള വിഷയങ്ങളും ഞങ്ങൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Operating systems play a key role in reversing.","translation":"ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ റിവേഴ്സിംഗിൽ ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"That’s because programs are tightly integrated with operating systems, and plenty of information can be gathered by probing this interface.","translation":"കാരണം പ്രോഗ്രാമുകൾ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുമായി ശക്തമായി സംയോജിപ്പിച്ചിരിക്കുന്നു, കൂടാതെ ഈ ഇന്റർഫേസ് പരിശോധിക്കുന്നതിലൂടെ ധാരാളം വിവരങ്ങൾ ശേഖരിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Moreover, the eventual bottom line of every program is in its communication with the outside world.","translation":"കൂടാതെ, എല്ലാ പ്രോഗ്രാമിന്റെയും ആത്യന്തികമായ ലക്ഷ്യം പുറം ലോകവുമായുള്ള ആശയവിനിമയത്തിലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This chapter introduces the architecture of the latest generations of the Microsoft Windows operating system.","translation":"ഈ അധ്യായം, ഏറ്റവും പുതിയ തലമുറയിലെ Microsoft Windows ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ ആർക്കിടെക്ചർ അവതരിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"If you feel perfectly comfortable with operating systems in general and with the Windows architecture in particular, feel free to skip this chapter.","translation":"നിങ്ങൾ പൊതുവെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളെക്കുറിച്ചും, പ്രത്യേകിച്ചും വിൻഡോസ് ആർക്കിടെക്ചറിനെക്കുറിച്ചും നന്നായി അറിയുന്നുണ്ടെങ്കിൽ, ഈ അധ്യായം ഒഴിവാക്കാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is important to realize that this discussion is really a brief overview of information that could fill several thick books.","translation":"ഈ ചർച്ച, നിരവധി പുസ്തകങ്ങളിൽ ഉൾക്കൊള്ളിക്കാൻ കഴിയുന്ന വിവരങ്ങളുടെ ഒരു സംക്ഷിപ്ത രൂപമാണെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"As you probably know, there used to be two different operating systems called Windows: Windows and Windows NT.","translation":"നിങ്ങൾക്ക് അറിയാവുന്നതുപോലെ, വിൻഡോസ് എന്ന് വിളിക്കപ്പെടുന്ന രണ്ട് വ്യത്യസ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ ഉണ്ടായിരുന്നു: വിൻഡോസും വിൻഡോസ് എൻടിയും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Windows NT was designed from the ground up as a 32-bit, virtual memory capable, multithreaded and multiprocessor-capable operating system.","translation":"വിൻഡോസ് എൻ്റിനെ 32-ബിറ്റ്, വിർച്വൽ മെമ്മറി ശേഷിയുള്ളതും, മൾട്ടിത്രെഡ്ഡും, മൾട്ടിപ്രൊസസ്സർ ശേഷിയുമുള്ളതുമായ ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റമായിട്ടാണ് രൂപകൽപ്പന ചെയ്തത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In 2001 Microsoft finally decided to eliminate the old Windows product and to only offer NT-based systems.","translation":"2001-ൽ, പഴയ വിൻഡോസ് ഉൽപ്പന്നം ഇല്ലാതാക്കാനും എൻ്റി അടിസ്ഥാനമാക്കിയുള്ള സിസ്റ്റങ്ങൾ മാത്രം നൽകാനും Microsoft തീരുമാനിച്ചു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The operating system described in this chapter is essentially Windows XP.","translation":"ഈ അധ്യായത്തിൽ വിവരിക്കുന്ന ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പ്രധാനമായും വിൻഡോസ് XP ആണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Pure 32-bit ArchitectureNow that the transition to 64-bit computing is already well on the way this may not sound like much, but Windows NT is a pure 32-bit computing environment, free of old 16-bit relics.","translation":"ശുദ്ധമായ 32-ബിറ്റ് ആർക്കിടെക്ചർ, 64-ബിറ്റ് കമ്പ്യൂട്ടിംഗിലേക്കുള്ള മാറ്റം ഇപ്പോൾ നടന്നുകൊണ്ടിരിക്കുകയാണ്, ഇത് അത്ര വലുതായി തോന്നണമെന്നില്ല, എന്നാൽ വിൻഡോസ് എൻ്റി ഒരു ശുദ്ധമായ 32-ബിറ്റ് കമ്പ്യൂട്ടിംഗ് പരിതസ്ഥിതിയാണ്, പഴയ 16-ബിറ്റ് അവശിഷ്ടങ്ങൾ ഇതിൽ നിന്ന് ഒഴിവാക്കിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Supports Virtual-MemoryWindows NT’s memory manager employs a full-blown virtual-memory model.","translation":"വിർച്വൽ മെമ്മറിയെ പിന്തുണയ്ക്കുന്നു, വിൻഡോസ് എൻ്റിയുടെ മെമ്മറി മാനേജർ ഒരു പൂർണ്ണമായ വിർച്വൽ മെമ്മറി മോഡൽ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Windows NT is a fully preemptive, multithreaded system.","translation":"വിൻഡോസ് എൻ്റി പൂർണ്ണമായും പ്രീ-എംപ്റ്റീവ്, മൾട്ടിത്രെഡ്ഡ് സിസ്റ്റമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The idea is that instead of letting software directly access physical memory, the processor, in combination with the operating system, creates an invisible layer between the software and the physical memory.","translation":"സോഫ്റ്റ്‌വെയറിനെ നേരിട്ട് ഫിസിക്കൽ മെമ്മറി ആക്സസ് ചെയ്യാൻ അനുവദിക്കുന്നതിനുപകരം, പ്രോസസ്സർ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റവുമായി ചേർന്ന്, സോഫ്റ്റ്‌വെയറിനും ഫിസിക്കൽ മെമ്മറിക്കും ഇടയിൽ ഒരു അദൃശ്യമായ പാളി സൃഷ്ടിക്കുന്നു എന്നതാണ് ഇതിൻ്റെ ആശയം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Kernel APIs are implemented in the KERNEL32.DLL module.","translation":"KERNEL32.DLL മൊഡ്യൂളിലാണ് കേർണൽ API-കൾ നടപ്പിലാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"These APIs include non-GUI related services.","translation":"ഈ API-കളിൽ GUI-യുമായി ബന്ധമില്ലാത്ത സേവനങ്ങളും ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Kernel APIs are used for file I/O and memory management.","translation":"ഫയൽ I/O, മെമ്മറി മാനേജ്മെൻ്റ് എന്നിവയ്ക്കായി കേർണൽ API-കൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"GDI APIs include low-level graphics services.","translation":"GDI API-കളിൽ കുറഞ്ഞ നിലയിലുള്ള ഗ്രാഫിക്സ് സേവനങ്ങളും ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"USER APIs include higher-level GUI-related services.","translation":"USER API-കളിൽ ഉയർന്ന നിലയിലുള്ള GUI-യുമായി ബന്ധപ്പെട്ട സേവനങ്ങളും ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The native API is the actual interface to the Windows NT system.","translation":"നേറ്റീവ് API വിൻഡോസ് എൻ്റി സിസ്റ്റത്തിലേക്കുള്ള യഥാർത്ഥ ഇൻ്റർഫേസാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Application programs are not supposed to directly call the native API.","translation":"ആപ്ലിക്കേഷൻ പ്രോഗ്രാമുകൾ നേറ്റീവ് API-യെ നേരിട്ട് വിളിക്കാൻ പാടില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Microsoft retained the freedom to change the native API.","translation":"നേറ്റീവ് API മാറ്റാനുള്ള സ്വാതന്ത്ര്യം Microsoft നിലനിർത്തി.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Sometimes understanding a native API is crucial.","translation":"ചിലപ്പോൾ ഒരു നേറ്റീവ് API മനസ്സിലാക്കുന്നത് നിർണായകമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The native API is a set of functions exported from NTDLL.DLL.","translation":"നേറ്റീവ് API എന്നത് NTDLL.DLL-ൽ നിന്ന് എക്സ്പോർട്ട് ചെയ്ത ഫംഗ്ഷനുകളുടെ ഒരു കൂട്ടമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"APIs in the native API always start with Nt or Zw.","translation":"നേറ്റീവ് API-യിലെ API-കൾ എപ്പോഴും Nt അല്ലെങ്കിൽ Zw എന്നിവയിൽ ആരംഭിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Every native API has two versions, an Nt version and a Zw version.","translation":"ഓരോ നേറ്റീവ് API-ക്കും രണ്ട് പതിപ്പുകളുണ്ട്, ഒരു Nt പതിപ്പും ഒരു Zw പതിപ്പും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The Zw versions are stubs that go through the system-call mechanism.","translation":"Zw പതിപ്പുകൾ സിസ്റ്റം-കോൾ മെക്കാനിസത്തിലൂടെ കടന്നുപോകുന്ന സ്റ്റബ്ബുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The system-call mechanism is important to understand.","translation":"സിസ്റ്റം-കോൾ മെക്കാനിസം മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"A system call takes place when user-mode code needs to call a kernel-mode function.","translation":"യൂസർ-മോഡ് കോഡിന് ഒരു കേർണൽ-മോഡ് ഫംഗ്ഷനെ വിളിക്കേണ്ടിവരുമ്പോഴാണ് ഒരു സിസ്റ്റം കോൾ നടക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Operating systems use a special mechanism for switching from user mode to kernel mode.","translation":"ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ യൂസർ മോഡിൽ നിന്ന് കേർണൽ മോഡിലേക്ക് മാറാൻ ഒരു പ്രത്യേക സംവിധാനം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The general idea is that user-mode code invokes a special CPU instruction.","translation":"പൊതുവായ ആശയം, യൂസർ-മോഡ് കോഡ് ഒരു പ്രത്യേക CPU നിർദ്ദേശം വിളിക്കുന്നു എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The EAX register is loaded with the service number.","translation":"EAX രജിസ്റ്ററിൽ സേവന നമ്പർ ലോഡ് ചെയ്യപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Executable files are relocatable.","translation":"എക്സിക്യൂട്ടബിൾ ഫയലുകൾ റീലൊക്കേറ്റ് ചെയ്യാവുന്നവയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Relocation happens because an executable must coexist with other executables.","translation":"ഒരു എക്സിക്യൂട്ടബിൾ മറ്റ് എക്സിക്യൂട്ടബിളുകളുമായി സഹവർത്തിക്കേണ്ടതുണ്ട് എന്നതിനാലാണ് റീലൊക്കേഷൻ സംഭവിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"IDA is a remarkably flexible product.","translation":"IDA ഒരു ശ്രദ്ധേയമായ രീതിയിൽ സൗകര്യപ്രദമായ ഉൽപ്പന്നമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"IDA is capable of producing powerful flowcharts for a given function.","translation":"ഒരു പ്രത്യേക ഫംഗ്ഷനായി ശക്തമായ ഫ്ലോചാർട്ടുകൾ ഉണ്ടാക്കാൻ IDA-ക്ക് കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"These are essentially logical graphs that show chunks of disassembled code.","translation":"ഇവ പ്രധാനമായും ലോജിക്കൽ ഗ്രാഫുകളാണ്, അത് വിഘടിപ്പിച്ച കോഡിന്റെ ഭാഗങ്ങൾ കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The boxes are connected by arrows that show the flow of the code.","translation":"കോഡിന്റെ ഒഴുക്ക് കാണിക്കുന്ന അമ്പടയാളങ്ങൾ ഉപയോഗിച്ചാണ് ഈ ബോക്സുകൾ ബന്ധിപ്പിച്ചിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Figure 4.3 shows an IDA-generated function flowchart.","translation":"ചിത്രം 4.3 IDA ഉണ്ടാക്കിയ ഒരു ഫംഗ്ഷൻ ഫ്ലോചാർട്ട് കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"IDA can produce interfunction charts.","translation":"IDA-ക്ക് ഇന്റർഫംഗ്ഷൻ ചാർട്ടുകൾ ഉണ്ടാക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The graph shows internal subroutines.","translation":"ഗ്രാഫ് ആന്തരിക സബ്‌റൂട്ടീനുകൾ കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The arrows coming out of each subroutine represents function calls.","translation":"ഓരോ സബ്‌റൂട്ടീനിൽ നിന്നും പുറത്തേക്ക് വരുന്ന അമ്പടയാളങ്ങൾ ഫംഗ്ഷൻ കോളുകളെ പ്രതിനിധീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Arrows that point to a subroutine show you who in the program calls that subroutine.","translation":"ഒരു സബ്‌റൂട്ടീനിലേക്ക് ചൂണ്ടുന്ന അമ്പടയാളങ്ങൾ ആ പ്രോഗ്രാമിലെ ആരെല്ലാമാണ് ആ സബ്‌റൂട്ടീനെ വിളിക്കുന്നതെന്ന് കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"IDA also has a variety of little features that make it very convenient to use.","translation":"IDA-യ്ക്ക് ഉപയോഗിക്കാൻ വളരെ സൗകര്യപ്രദമാക്കുന്ന നിരവധി ചെറിയ സവിശേഷതകളും ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For example, if you click the word EAXin an instruction, all references to EAXin the current page of disassembled code will be highlighted.","translation":"ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു നിർദ്ദേശത്തിൽ EAX എന്ന വാക്ക് ക്ലിക്ക് ചെയ്താൽ, വിഘടിപ്പിച്ച കോഡിന്റെ നിലവിലെ പേജിലെ EAX-ലേക്കുള്ള എല്ലാ റഫറൻസുകളും ഹൈലൈറ്റ് ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This makes it much easier to read disassembled listings.","translation":"ഇത് വിഘടിപ്പിച്ച ലിസ്റ്റിംഗുകൾ വായിക്കുന്നത് വളരെ എളുപ്പമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"ILDasm is a disassembler for the Microsoft Intermediate Language (MSIL).","translation":"ILDasm എന്നത് Microsoft Intermediate Language (MSIL) എന്നതിനായുള്ള ഒരു ഡിസ്അസംബ്ലർ ആണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is listed here because this book also discusses .NET reversing.","translation":"ഈ പുസ്തകത്തിൽ .NET റിവേഴ്സിംഗിനെക്കുറിച്ചും ചർച്ച ചെയ്യുന്നതുകൊണ്ടാണ് ഇത് ഇവിടെ ലിസ്റ്റ് ചെയ്തിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Debuggers exist primarily to assist software developers.","translation":"പ്രധാനമായും സോഫ്റ്റ്‌വെയർ ഡെവലപ്പർമാരെ സഹായിക്കാനാണ് ഡീബഗ്ഗറുകൾ നിലവിലുള്ളത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Most native code debuggers have some kind of support for stepping through assembly language code.","translation":"മിക്ക നേറ്റീവ് കോഡ് ഡീബഗ്ഗറുകളും അസംബ്ലി ലാംഗ്വേജ് കോഡിലൂടെ കടന്നുപോകുന്നതിന് ചില തരത്തിലുള്ള പിന്തുണ നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The idea is that the debugger provides a disassembled view of the currently running function.","translation":"നിലവിൽ പ്രവർത്തിക്കുന്ന ഫംഗ്ഷന്റെ വിഘടിപ്പിച്ച കാഴ്ച ഡീബഗ്ഗർ നൽകുന്നു എന്നതാണ് ഇതിലെ ആശയം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"A powerful disassembler is a mandatory feature in a good reversing debugger.","translation":"ഒരു നല്ല റിവേഴ്സിംഗ് ഡീബഗ്ഗറിൽ ശക്തമായ ഡിസ്അസംബ്ലർ ഒരു നിർബന്ധിത ഘടകമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Software breakpoints are instructions added into the program’s code by the debugger at runtime.","translation":"സോഫ്റ്റ്‌വെയർ ബ്രേക്ക്‌പോയിന്റുകൾ എന്നത് റൺടൈമിൽ ഡീബഗ്ഗർ പ്രോഗ്രാമിന്റെ കോഡിലേക്ക് ചേർക്കുന്ന നിർദ്ദേശങ്ങളാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Kernel-mode debuggers are far more powerful.","translation":"കെർണൽ-മോഡ് ഡീബഗ്ഗറുകൾ വളരെ ശക്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The Import Address Table (IAT) contains a list of entries for each function imported from the current module.","translation":"ഇറക്കുമതി ചെയ്ത ഓരോ ഫംഗ്ഷനുമായുള്ള എൻട്രികളുടെ ഒരു ലിസ്റ്റ്, നിലവിലെ മൊഡ്യൂളിൽ നിന്ന് ഇറക്കുമതി ചെയ്തവ, ഇംപോർട്ട് വിലാസ പട്ടികയിൽ (IAT) അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This directory is used for confirming that such addresses are still valid.","translation":"അത്തരം വിലാസങ്ങൾ ഇപ്പോഴും സാധുതയുള്ളതാണെന്ന് സ്ഥിരീകരിക്കുന്നതിന് ഈ ഡയറക്ടറി ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"I/O can be relevant to reversing because tracing a program’s communications with the outside world is much easier than doing code-level reversing.","translation":"ഒരു പ്രോഗ്രാമിന്റെ കമ്മ്യൂണിക്കേഷൻ ബാഹ്യലോകവുമായി പിന്തുടരുന്നത് കോഡ് ലെവൽ റിവേഴ്സിംഗിനേക്കാൾ എളുപ്പമായതുകൊണ്ട്, I/O റിവേഴ്സിംഗുമായി ബന്ധപ്പെട്ടതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The I/O system is responsible for relaying such request from the application to the device driver responsible for per- forming the operation.","translation":"ഓപ്പറേഷൻ നടപ്പിലാക്കാൻ ഉത്തരവാദിയായ, ആപ്ലിക്കേഷനിൽ നിന്നുള്ള ഇത്തരം അഭ്യർത്ഥനകൾ, ഉപകരണ ഡ്രൈവറിലേക്ക് എത്തിക്കുന്നത് I/O സിസ്റ്റമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This layered architecture also makes it relatively easy to add filter drivers.","translation":"ഈ ലേയേർഡ് ആർക്കിടെക്ചർ ഫിൽട്ടർ ഡ്രൈവറുകൾ ചേർക്കുന്നത് താരതമ്യേന എളുപ്പമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The Win32 subsystem is the component responsible for every aspect of the Windows user interface.","translation":"വിൻഡോസ് യൂസർ ഇന്റർഫേസിന്റെ എല്ലാ കാര്യങ്ങൾക്കും ഉത്തരവാദിയായ ഘടകമാണ് Win32 സബ്സിസ്റ്റം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Suppose, for example, that you’re trying to find the code in a program that displays a certain window, or the code that processes a certain user event.","translation":"ഉദാഹരണത്തിന്, ഒരു പ്രത്യേക ജാലകം പ്രദർശിപ്പിക്കുന്ന അല്ലെങ്കിൽ ഒരു പ്രത്യേക ഉപയോക്തൃ ഇവന്റ് പ്രോസസ്സ് ചെയ്യുന്ന ഒരു പ്രോഗ്രാമിലെ കോഡ് കണ്ടെത്താൻ നിങ്ങൾ ശ്രമിക്കുകയാണെന്ന് കരുതുക.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Handles to Win32 objects such as windows and device contexts are essentially indexes into these object tables.","translation":"വിൻഡോസ്, ഡിവൈസ് കോൺടെക്സ്റ്റുകൾ പോലുള്ള Win32 ഒബ്ജക്റ്റുകളിലേക്കുള്ള ഹാൻഡിലുകൾ, ഈ ഒബ്ജക്റ്റ് ടേബിളുകളിലേക്കുള്ള സൂചികകളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Hardware exceptions are exceptions generated by the processor, for example when a program accesses an invalid memory page (a page fault) or when a division by zero occurs.","translation":"പ്രോസസ്സർ ഉണ്ടാക്കുന്ന ഒഴിവാക്കലുകളാണ് ഹാർഡ്‌വെയർ ഒഴിവാക്കലുകൾ, ഉദാഹരണത്തിന്, ഒരു പ്രോഗ്രാം സാധുതയില്ലാത്ത മെമ്മറി പേജ് ആക്സസ് ചെയ്യുമ്പോൾ (പേജ് ഫോൾട്ട്) അല്ലെങ്കിൽ പൂജ്യത്തിലേക്ക് ഭാഗിക്കുമ്പോൾ.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Structured exception handling means that the operating system provides mechanisms for “distributing” exceptions to applications in an organized manner.","translation":"സംഘടിത രീതിയിൽ ആപ്ലിക്കേഷനുകളിലേക്ക് ഒഴിവാക്കലുകൾ വിതരണം ചെയ്യുന്നതിനുള്ള സംവിധാനങ്ങൾ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നൽകുന്നു എന്നാണ് ഘടനാപരമായ ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ അർത്ഥമാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The TIB is stored in a regular private-allocation user-mode memory.","translation":"TIB സാധാരണ സ്വകാര്യ-അലോക്കേഷൻ ഉപയോക്തൃ-മോഡ് മെമ്മറിയിൽ സംഭരിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"On IA-32 processors, Windows uses the FS segment reg- ister as a pointer to the currently active thread-specific data structures.","translation":"IA-32 പ്രോസസ്സറുകളിൽ, നിലവിൽ സജീവമായ ത്രെഡ്-നിർദ്ദിഷ്ട ഡാറ്റാ ഘടനകളിലേക്ക് ഒരു പോയിന്ററായി FS സെഗ്‌മെന്റ് രജിസ്റ്റർ വിൻഡോസ് ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"When an exception is generated, the processor calls the registered handler from the IDT.","translation":"ഒരു ഒഴിവാക്കൽ ഉണ്ടാകുമ്പോൾ, IDT-യിൽ നിന്ന് രജിസ്റ്റർ ചെയ്ത ഹാൻഡ്ലറെ പ്രോസസ്സർ വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Let’s take a page-fault exception as an example.","translation":"ഒരു പേജ്-ഫോൾട്ട് ഒഴിവാക്കൽ ഒരു ഉദാഹരണമായി എടുക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"KiUserExceptionDispatcher calls into RtlDispatchException, which is responsible for going through the linked list at ExceptionList and looking for an exception handler that can deal with the exception.","translation":"KiUserExceptionDispatcher, ExceptionList-ൽ ലിങ്ക്ഡ് ലിസ്റ്റിലൂടെ കടന്നുപോവുകയും, ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ഒരു ഒഴിവാക്കൽ ഹാൻഡ്ലറെ തിരയുകയും ചെയ്യുന്ന RtlDispatchException-ലേക്ക് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This sequence simply adds an _EXCEPTION_REGISTRATION_RECORD entry into the current thread’s exception handler list.","translation":"ഈ ശ്രേണി, നിലവിലെ ത്രെഡിന്റെ ഒഴിവാക്കൽ ഹാൻഡ്ലർ ലിസ്റ്റിലേക്ക് ഒരു _EXCEPTION_REGISTRATION_RECORD എൻട്രി ചേർക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In real-life you will rarely run into simple exception handler setup sequences such as the one just shown.","translation":"യഥാർത്ഥ ജീവിതത്തിൽ, ഇപ്പോൾ കാണിച്ചതുപോലെയുള്ള ലളിതമായ ഒഴിവാക്കൽ ഹാൻഡ്ലർ സജ്ജീകരണ ശ്രേണികൾ നിങ്ങൾ വളരെ അപൂർവമായി മാത്രമേ കാണാറുള്ളൂ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The compiler has extended the _EXCEPTION_REGISTRATION_RECORD data structure and has added two new members.","translation":"കംപൈലർ _EXCEPTION_REGISTRATION_RECORD ഡാറ്റാ ഘടന വികസിപ്പിക്കുകയും രണ്ട് പുതിയ അംഗങ്ങളെ ചേർക്കുകയും ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Vectored exception handlers are installed using the Win32 API AddVectoredExceptionHandler.","translation":"Win32 API AddVectoredExceptionHandler ഉപയോഗിച്ചാണ് വെക്റ്റേർഡ് ഒഴിവാക്കൽ ഹാൻഡ്ലറുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Understanding the differences between these tools and choosing the right ones is critical.","translation":"ഈ ടൂളുകൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ മനസ്സിലാക്കുകയും ശരിയായവ തിരഞ്ഞെടുക്കുകയും ചെയ്യുന്നത് നിർണായകമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The disassembled listings in this book were produced using more than one disassembler.","translation":"ഈ പുസ്തകത്തിലെ ഡിസ്അസംബിൾ ചെയ്ത ലിസ്റ്റിംഗുകൾ ഒന്നിലധികം ഡിസ്അസംബ്ലർ ഉപയോഗിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Generally speaking, most of the code listings were produced using OllyDbg.","translation":"പൊതുവേ പറഞ്ഞാൽ, കോഡ് ലിസ്റ്റിംഗുകളുടെ ഭൂരിഭാഗവും ഒലിഡിബിജി ഉപയോഗിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Even though OllyDbg is a debugger, I find its internal disassembler quite powerful.","translation":"ഒലിഡിബിജി ഒരു ഡീബഗ്ഗർ ആണെങ്കിലും, അതിൻ്റെ ഇന്റേണൽ ഡിസ്അസംബ്ലർ വളരെ ശക്തമാണെന്ന് ഞാൻ കരുതുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Locating Undocumented APIs is a key part of reverse engineering.","translation":"രേഖപ്പെടുത്താത്ത API-കൾ കണ്ടെത്തുന്നത് റിവേഴ്സ് എഞ്ചിനീയറിംഗിൻ്റെ ഒരു പ്രധാന ഭാഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In this chapter you will be taking a group of undocumented Windows APIs and practicing your reversing skills on them.","translation":"ഈ അധ്യായത്തിൽ, രേഖപ്പെടുത്താത്ത വിൻഡോസ് API-കളുടെ ഒരു ഗ്രൂപ്പ് എടുത്ത് അതിൽ നിങ്ങളുടെ റിവേഴ്സിംഗ് കഴിവുകൾ പരിശീലിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Before introducing the specific APIs you will be working with, let’s take a quick look at how I found those APIs.","translation":"നിങ്ങൾ പ്രവർത്തിക്കാൻ പോകുന്ന നിർദ്ദിഷ്ട API-കളെക്കുറിച്ച് പറയുന്നതിനുമുമ്പ്, ഞാൻ എങ്ങനെയാണ് ആ API-കൾ കണ്ടെത്തിയതെന്ന് നമുക്ക് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The next section describes the first steps in dealing with undocumented code.","translation":"അടുത്ത ഭാഗത്ത് രേഖപ്പെടുത്താത്ത കോഡുമായി എങ്ങനെ ഇടപെടാം എന്നതിൻ്റെ ആദ്യ ഘട്ടങ്ങൾ വിവരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Typically, the search for undocumented code starts with a requirement.","translation":"സാധാരണയായി, രേഖപ്പെടുത്താത്ത കോഡിനായുള്ള തിരയൽ ഒരു ആവശ്യകതയിൽ നിന്നാണ് ആരംഭിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"What functionality is missing?","translation":"എന്താണ് പ്രവർത്തനക്ഷമത നഷ്ടപ്പെട്ടത്?","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"You need to be aware of the key executable modules that make up the program.","translation":"പ്രോഗ്രാം ഉണ്ടാക്കുന്ന പ്രധാന എക്സിക്യൂട്ടബിൾ മൊഡ്യൂളുകളെക്കുറിച്ച് നിങ്ങൾ ബോധവാന്മാരായിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Interfaces between binary modules are easy to observe simply by dumping the import and export directories.","translation":"ബൈനറി മൊഡ്യൂളുകൾ തമ്മിലുള്ള ഇന്റർഫേസുകൾ, ഇംപോർട്ട്, എക്സ്പോർട്ട് ഡയറക്ടറികൾ എന്നിവ ഡംപ് ചെയ്യുന്നതിലൂടെ എളുപ്പത്തിൽ നിരീക്ഷിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In this particular case, I have decided to look for an interesting Windows API to dissect.","translation":"ഈ പ്രത്യേക കേസിൽ, വിഭജിക്കാൻ ഒരു രസകരമായ വിൻഡോസ് API-ക്കായി തിരയാൻ ഞാൻ തീരുമാനിച്ചു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Knowing that the majority of undocumented user-mode services in Windows are implemented in NTDLL.DLL.","translation":"വിൻഡോസിലെ രേഖപ്പെടുത്താത്ത ഉപയോക്തൃ-മോഡ് സേവനങ്ങളുടെ ഭൂരിഭാഗവും NTDLL.DLL-ൽ നടപ്പിലാക്കിയിരിക്കുന്നു എന്ന് അറിയുക.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"I simply dumped the export directory of NTDLL.DLL and visually scanned that list for groups of APIs that appear related.","translation":"ഞാൻ NTDLL.DLL-ൻ്റെ എക്സ്പോർട്ട് ഡയറക്ടറി ഡംപ് ചെയ്യുകയും ബന്ധപ്പെട്ട API-കളുടെ ഗ്രൂപ്പുകൾക്കായി ആ ലിസ്റ്റ് ദൃശ്യപരമായി സ്കാൻ ചെയ്യുകയും ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In most cases, you won’t just be looking for undocumented APIs just because they’re undocumented.","translation":"മിക്ക കേസുകളിലും, രേഖപ്പെടുത്താത്ത API-കൾ രേഖപ്പെടുത്തിയിട്ടുണ്ട് എന്നതുകൊണ്ട് മാത്രം നിങ്ങൾ അവയെ തിരയുകയില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Suppose, for example, that you want to look for some kind of special memory allocation API.","translation":"ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു പ്രത്യേക തരം മെമ്മറി അലോക്കേഷൻ API-ക്കായി തിരയാൻ ആഗ്രഹിക്കുന്നു എന്ന് കരുതുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Once you find the name of an undocumented API and the name of the DLL that exports it, it’s time to look for binaries that use it.","translation":"രേഖപ്പെടുത്താത്ത API-യുടെ പേരും അത് എക്സ്പോർട്ട് ചെയ്യുന്ന DLL-ൻ്റെ പേരും കണ്ടെത്തിയാൽ, അത് ഉപയോഗിക്കുന്ന ബൈനറികൾക്കായി തിരയാനുള്ള സമയമാണിത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Finding an executable that calls the API will serve two purposes.","translation":"API-യെ വിളിക്കുന്ന ഒരു എക്സിക്യൂട്ടബിൾ കണ്ടെത്തുന്നത് രണ്ട് ആവശ്യങ്ങൾ നിറവേറ്റും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The traditional approach uses a kernel-mode debugger such as Numega SoftICE or Microsoft WinDbg.","translation":"പരമ്പരാഗത സമീപനം Numega SoftICE അല്ലെങ്കിൽ Microsoft WinDbg പോലുള്ള ഒരു കേർണൽ-മോഡ് ഡീബഗ്ഗർ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s dive headfirst into our very first hands-on reverse-engineering session.","translation":"നമ്മുടെ ആദ്യത്തെ പ്രായോഗിക റിവേഴ്സ് എഞ്ചിനീയറിംഗ് സെഷനിലേക്ക് കടക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The best example is the code that SoftICE uses for showing its window—any code that accesses the screen is difficult to step through in SoftICE because it tries to draw to the screen, while SoftICE is showing its debugging window.","translation":"SoftICE വിൻഡോ കാണിക്കാൻ ഉപയോഗിക്കുന്ന കോഡാണ് ഏറ്റവും മികച്ച ഉദാഹരണം - സ്ക്രീനിലേക്ക് ചിത്രീകരിക്കാൻ ശ്രമിക്കുന്നതിനാൽ, സ്ക്രീനിലേക്ക് പ്രവേശിക്കുന്ന ഏതൊരു കോഡും SoftICE-ൽ കൂടി കടന്നുപോകുമ്പോൾ ബുദ്ധിമുട്ടാണ്, അതേസമയം SoftICE അതിന്റെ ഡീബഗ്ഗിംഗ് വിൻഡോ കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"ICE stands for in circuit emulator, which is a popular tool for performing extremely low-level debugging.","translation":"ICE എന്നാൽ ഇൻ സർക്യൂട്ട് എമുലേറ്റർ എന്നാണ് അർത്ഥമാക്കുന്നത്, ഇത് വളരെ താഴ്ന്ന നിലയിലുള്ള ഡീബഗ്ഗിംഗ് നടപ്പിലാക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ജനപ്രിയ ഉപകരണമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"SoftICE stands for a Software ICE, which implies that SoftICE is like a software implementation of an in circuit emulator.","translation":"SoftICE എന്നാൽ സോഫ്റ്റ്‌വെയർ ICE എന്നാണ് അർത്ഥമാക്കുന്നത്, അതായത് SoftICE ഒരു ഇൻ സർക്യൂട്ട് എമുലേറ്ററിന്റെ സോഫ്റ്റ്‌വെയർ നടപ്പിലാക്കലിന് സമാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Figure 4.9 shows what SoftICE looks like when it is opened.","translation":"ചിത്രം 4.9 സോഫ്റ്റ്‌ഐസ് തുറക്കുമ്പോൾ എങ്ങനെയിരിക്കുമെന്ന് കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The original Windows screen stays in the background, and the SoftICE window is opened in the center of the screen.","translation":"തുടക്കത്തിലുള്ള വിൻഡോസ് സ്ക്രീൻ പശ്ചാത്തലത്തിൽ തുടരുന്നു, കൂടാതെ സോഫ്റ്റ്‌ഐസ് വിൻഡോ സ്ക്രീനിന്റെ മധ്യഭാഗത്ത് തുറക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It is easy to notice that the SoftICE window has no border and is completely detached from the Windows windowing system.","translation":"സോഫ്റ്റ്‌ഐസ് വിൻഡോയ്ക്ക് അതിരുകളില്ലെന്നും വിൻഡോസ് വിൻഡോയിംഗ് സിസ്റ്റത്തിൽ നിന്ന് പൂർണ്ണമായും വേർപെട്ടതാണെന്നും ശ്രദ്ധിക്കാൻ എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Because kernel debugging freezes and potentially destabilizes the operating system on which it is performed, it is highly advisable to use a dedicated system for kernel debugging, and to never use a kernel debugger on your primary computer.","translation":"കെർണൽ ഡീബഗ്ഗിംഗ് നടപ്പിലാക്കുന്ന ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തെ മരവിപ്പിക്കുകയും സ്ഥിരതയില്ലാത്തതാക്കുകയും ചെയ്യുന്നതിനാൽ, കെർണൽ ഡീബഗ്ഗിംഗിനായി ഒരു പ്രത്യേക സിസ്റ്റം ഉപയോഗിക്കുന്നതും നിങ്ങളുടെ പ്രധാന കമ്പ്യൂട്ടറിൽ ഒരു കെർണൽ ഡീബഗ്ഗർ ഉപയോഗിക്കാതിരിക്കുന്നതും വളരെ നല്ലതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Virtual machines are perfect for kernel debugging because they allow for the creation of isolated systems that can be kernel debugged at any time, and even concurrently (assuming the host has enough memory to support them), without having any effect on the stability of the host.","translation":"കെർണൽ ഡീബഗ്ഗിംഗിനായി വിർച്വൽ മെഷീനുകൾ വളരെ മികച്ചതാണ്, കാരണം ഏത് സമയത്തും കെർണൽ ഡീബഗ് ചെയ്യാവുന്നതും, ഒരേ സമയം (ഹോസ്റ്റിന് അവയെ പിന്തുണയ്ക്കാൻ ആവശ്യമായ മെമ്മറി ഉണ്ടെങ്കിൽ) ഹോസ്റ്റിന്റെ സ്ഥിരതയെ ബാധിക്കാത്തതുമായ, ഒറ്റപ്പെട്ട സിസ്റ്റങ്ങൾ ഉണ്ടാക്കാൻ ഇത് അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Having the system’s hard drive in a single file on the host really simplifies management and backups.","translation":"ഹോസ്റ്റിലെ ഒരു ഫയലിൽ സിസ്റ്റത്തിന്റെ ഹാർഡ് ഡ്രൈവ് ഉണ്ടാകുന്നത് മാനേജ്മെന്റും ബാക്കപ്പുകളും ശരിക്കും ലളിതമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Virtual machines also offer a variety of additional features that make them attractive for users requiring kernel debugging.","translation":"കെർണൽ ഡീബഗ്ഗിംഗ് ആവശ്യമുള്ള ഉപയോക്താക്കൾക്ക് ആകർഷകമാക്കുന്ന നിരവധി അധിക ഫീച്ചറുകളും വിർച്വൽ മെഷീനുകൾ വാഗ്ദാനം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For instance, it is possible to store one state of the system and then make some con- figuration changes—going back to the original configuration is just a matter of copying the original file back, much easier than with a nonvirtual system.","translation":"ഉദാഹരണത്തിന്, സിസ്റ്റത്തിന്റെ ഒരു അവസ്ഥ സംഭരിക്കാനും തുടർന്ന് ചില കോൺഫിഗറേഷൻ മാറ്റങ്ങൾ വരുത്താനും കഴിയും - യഥാർത്ഥ കോൺഫിഗറേഷനിലേക്ക് മടങ്ങുന്നത് യഥാർത്ഥ ഫയൽ തിരികെ പകർത്തുന്നതുപോലെ ലളിതമാണ്, ഒരു വെർച്വൽ ഇതര സംവിധാനത്തേക്കാൾ വളരെ എളുപ്പമാണ് ഇത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Additionally, some virtual machine products support nonpersistent drives that discard anything written to the hard drive when the system is shut down or restarted.","translation":"കൂടാതെ, ചില വെർച്വൽ മെഷീൻ ഉൽപ്പന്നങ്ങൾ, സിസ്റ്റം ഷട്ട്ഡൗൺ ചെയ്യുമ്പോഴോ പുനരാരംഭിക്കുമ്പോഴോ ഹാർഡ് ഡ്രൈവിലേക്ക് എഴുതിയതെല്ലാം ഒഴിവാക്കുന്ന, നിലനിൽക്കാത്ത ഡ്രൈവുകളെ പിന്തുണയ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This feature is perfect for dealing with malicious software that might try to corrupt the disk or infect additional files because any changes made while the system is running are discarded when the system is shut down.","translation":"ഡിസ്ക് നശിപ്പിക്കാനോ അധിക ഫയലുകൾക്ക് കേടുവരുത്താനോ ശ്രമിക്കുന്ന ദോഷകരമായ സോഫ്റ്റ്‌വെയറുകളെ കൈകാര്യം ചെയ്യാൻ ഈ ഫീച്ചർ വളരെ മികച്ചതാണ്, കാരണം സിസ്റ്റം പ്രവർത്തിക്കുമ്പോൾ വരുത്തുന്ന ഏതൊരു മാറ്റവും സിസ്റ്റം ഷട്ട്ഡൗൺ ചെയ്യുമ്പോൾ ഒഴിവാക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Unsurprisingly, virtual machines require significant resources from the host.","translation":"ആശ്ചര്യകരമെന്നു പറയട്ടെ, വിർച്വൽ മെഷീനുകൾ ഹോസ്റ്റിൽ നിന്ന് കാര്യമായ വിഭവങ്ങൾ ആവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The two primary virtual machine technologies currently available are Virtual PC from Microsoft Corporation and VMWare Workstation from VMWare Inc.","translation":"നിലവിൽ ലഭ്യമായ രണ്ട് പ്രധാന വെർച്വൽ മെഷീൻ സാങ്കേതികവിദ്യകളാണ് Microsoft കോർപ്പറേഷന്റെ Virtual PC, VMWare Inc-ന്റെ VMWare Workstation എന്നിവ.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Functionally the two products are very similar, both being able to run Win- dows and non-Windows operating systems.","translation":"പ്രവർത്തനപരമായി ഈ രണ്ട് ഉൽപ്പന്നങ്ങളും വളരെ സമാനമാണ്, വിൻഡോസ്, വിൻഡോസ് ഇതര ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ പ്രവർത്തിപ്പിക്കാൻ രണ്ടിനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"One difference is that VMWare also runson non-Windows hosts such as Linux, allowing Linux systems to run versions of Windows (or other Linux installations) inside a virtual machine.","translation":"VMWare-ന് Linux പോലുള്ള വിൻഡോസ് ഇതര ഹോസ്റ്റുകളിലും പ്രവർത്തിക്കാൻ കഴിയും എന്നതാണ് ഒരു വ്യത്യാസം, ഇത് Linux സിസ്റ്റങ്ങളെ ഒരു വെർച്വൽ മെഷീനിനുള്ളിൽ വിൻഡോസിന്റെ (അല്ലെങ്കിൽ മറ്റ് Linux ഇൻസ്റ്റാളേഷനുകളുടെ) പതിപ്പുകൾ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Both products have full support for performing kernel-debugging using either WinDbg or NuMega SoftICE.","translation":"WinDbg അല്ലെങ്കിൽ NuMega SoftICE ഉപയോഗിച്ച് കെർണൽ-ഡീബഗ്ഗിംഗ് നടപ്പിലാക്കുന്നതിന് രണ്ട് ഉൽപ്പന്നങ്ങൾക്കും പൂർണ്ണ പിന്തുണയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Figure 4.10 shows a VMWare Workstation win- dow with a Windows Server 2003 system running inside it.","translation":"ചിത്രം 4.10-ൽ വിൻഡോസ് സെർവർ 2003 സിസ്റ്റം പ്രവർത്തിക്കുന്ന VMWare വർക്ക്‌സ്റ്റേഷൻ വിൻഡോ കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Decompilers are a reverser’s dream tool—they attempt to produce a high-level language source-code-like representation from a program binary.","translation":"ഡീകംപൈലറുകൾ ഒരു റിവേഴ്സറുടെ സ്വപ്ന ഉപകരണമാണ് - ഒരു പ്രോഗ്രാം ബൈനറിയിൽ നിന്ന് ഉയർന്ന തലത്തിലുള്ള ഭാഷാ സോഴ്സ് കോഡിന് സമാനമായ പ്രാതിനിധ്യം ഉണ്ടാക്കാൻ അവ ശ്രമിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Based on their names, it’s pretty easy to make some educated guesses on what they do.","translation":"അവരുടെ പേരുകൾ വെച്ച് നോക്കുമ്പോൾ, അവർ എന്താണ് ചെയ്യുന്നതെന്ന് ഏകദേശം ഊഹിക്കാൻ എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The easiest is RtlEnumerateGenericTable because it’s obvious that it enumerates some or all of the elements in the list.","translation":"ഏറ്റവും എളുപ്പം RtlEnumerateGenericTable ആണ്, കാരണം ഇത് ലിസ്റ്റിലെ ചില അല്ലെങ്കിൽ എല്ലാ ഘടകങ്ങളെയും എണ്ണുന്നു എന്നത് വ്യക്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The next question is what is the difference between RtlGetElementGenericTable and RtlLookup ElementGenericTable?","translation":"അടുത്ത ചോദ്യം, RtlGetElementGenericTable-ഉം RtlLookup ElementGenericTable-ഉം തമ്മിലുള്ള വ്യത്യാസം എന്താണ്?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It’s really impossible to know without looking at the code, but if I had to guess I’d say RtlGetElementGenericTable provides some kind of direct access to an element (probably using an index), and Rtl LookupElementGenericTable has to search for the right element.","translation":"കോഡ് നോക്കാതെ ഇത് ശരിക്കും അറിയാൻ കഴിയില്ല, പക്ഷേ എനിക്ക് ഊഹിക്കേണ്ടിവന്നാൽ, RtlGetElementGenericTable ഒരു ഘടകത്തിലേക്ക് (ഒരു സൂചിക ഉപയോഗിച്ച്) നേരിട്ടുള്ള പ്രവേശനം നൽകുന്നു എന്നും, ശരിയായ ഘടകം കണ്ടെത്താൻ RtlLookupElementGenericTable-ന് തിരയേണ്ടിവരുമെന്നും ഞാൻ പറയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If I’m right, RtlGetElementGenericTable will probably be the simpler function of the two.","translation":"ഞാൻ ശരിയാണെങ്കിൽ, RtlGetElementGenericTable, രണ്ടും തമ്മിൽ താരതമ്യം ചെയ്യുമ്പോൾ ലളിതമായ ഫംഗ്ഷനായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Listing 5.2 presents the full disassembly for RtlGetElementGenericTable.","translation":"RtlGetElementGenericTable-ന്റെ പൂർണ്ണമായ ഡിസ്അസംബ്ലിംഗ് ലിസ്റ്റിംഗ് 5.2-ൽ നൽകിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"See if you can figure some of it out by your- self before you proceed to the analysis that follows.","translation":"തുടർന്നുള്ള വിശകലനത്തിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, നിങ്ങൾക്ക് ഇതിൽ ചിലത് സ്വയം കണ്ടെത്താൻ കഴിയുമോ എന്ന് നോക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Just like the previous APIs, RtlGetElementGenericTablestarts with a conventional stack frame setup sequence.","translation":"മുമ്പത്തെ API-കളെപ്പോലെ, RtlGetElementGenericTable ഒരു പരമ്പരാഗത സ്റ്റാക്ക് ഫ്രെയിം സജ്ജീകരണ ശ്രേണിയോടെയാണ് ആരംഭിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This tells you that this function’s parameters are going to be accessed using EBPinstead of ESP.","translation":"ഈ ഫംഗ്ഷന്റെ പാരാമീറ്ററുകൾ ESP-ക്ക് പകരം EBP ഉപയോഗിച്ചാണ് ആക്സസ് ചെയ്യാൻ പോകുന്നതെന്ന് ഇത് നിങ്ങളോട് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Generic table APIs all seem to take the root table data structure as their first parameter, and there is no reason to assume that RtlGetElementGeneric Table is any different.","translation":"Generic table API-കൾ എല്ലാം റൂട്ട് ടേബിൾ ഡാറ്റാ ഘടനയെ ആദ്യത്തെ പാരാമീറ്ററായി എടുക്കുന്നതായി തോന്നുന്നു, കൂടാതെ RtlGetElementGeneric Table വ്യത്യസ്തമായിരിക്കുമെന്ന് അനുമാനിക്കാൻ ഒരു കാരണവുമില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In this sequence the function loads the root table pointer into ECX, and then loads the value stored at offset +14 into EDX.","translation":"ഈ ശ്രേണിയിൽ ഫംഗ്ഷൻ റൂട്ട് ടേബിൾ പോയിന്റർ ECX-ലേക്ക് ലോഡ് ചെയ്യുന്നു, തുടർന്ന് ഓഫ്‌സെറ്റ് +14-ൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യം EDX-ലേക്ക് ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Recall that in the dissection of RtlNumberGenericTableElementsit was established that offset +14 contains the total number of elements in the table.","translation":"RtlNumberGenericTableElements-ന്റെ വിഭജനത്തിൽ, ഓഫ്‌സെറ്റ് +14-ൽ ടേബിളിലെ മൊത്തം എലമെന്റുകളുടെ എണ്ണം അടങ്ങിയിരിക്കുന്നു എന്ന് സ്ഥാപിക്കപ്പെട്ടു എന്ന് ഓർക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The next instruction loads the third pointer at offset +0c from the three pointer group into EAX.","translation":"അടുത്ത നിർദ്ദേശം, മൂന്ന് പോയിന്റർ ഗ്രൂപ്പിൽ നിന്നുള്ള ഓഫ്‌സെറ്റ് +0c-ൽ മൂന്നാമത്തെ പോയിന്റർ EAX-ലേക്ക് ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This code starts out by pushing EBXand ESIinto the stack in order to pre- serve their original values (we know this because there are no function calls anywhere to be seen).","translation":"ഈ കോഡ് EBX, ESI എന്നിവയെ സ്റ്റാക്കിലേക്ക് തള്ളിവിടുന്നതിലൂടെ ആരംഭിക്കുന്നു, അതുവഴി അവയുടെ യഥാർത്ഥ മൂല്യങ്ങൾ സംരക്ഷിക്കാൻ കഴിയും (കാരണം, എവിടെയും ഫംഗ്ഷൻ കോളുകൾ കാണുന്നില്ല).","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The code then proceeds to load the value from offset +10 of the root structure into ESI, and then pushes EDIin order to start using it.","translation":"തുടർന്ന് കോഡ് റൂട്ട് ഘടനയുടെ ഓഫ്‌സെറ്റ് +10-ൽ നിന്നുള്ള മൂല്യം ESI-ലേക്ക് ലോഡ് ചെയ്യുന്നു, തുടർന്ന് ഇത് ഉപയോഗിക്കാൻ തുടങ്ങുന്നതിന് EDI-യെ തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"You know that EBP + Cpoints to the second parameter, just like EBP + 8 pointed to the first parameter.","translation":"EBP + 8 ആദ്യത്തെ പാരാമീറ്ററിലേക്ക് ചൂണ്ടിക്കാണിച്ചതുപോലെ, EBP + C രണ്ടാമത്തെ പാരാമീറ്ററിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു എന്ന് നിങ്ങൾക്കറിയാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"So, the instruction at ntdll.7C9624F2loads EDIwith the value of the second parameter passed into the function.","translation":"അതിനാൽ, ntdll.7C9624F2-ലെ നിർദ്ദേശം ഫംഗ്ഷനിലേക്ക് കൈമാറിയ രണ്ടാമത്തെ പാരാമീറ്ററിന്റെ മൂല്യം ഉപയോഗിച്ച് EDI-യെ ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Immediately afterward, EDIis compared against –1 and you see a classic case of inter- leaved code, which is a very common phenomena in code generated for modern IA-32 processors.","translation":"ഉടൻ തന്നെ, EDI -1-മായി താരതമ്യം ചെയ്യപ്പെടുന്നു, കൂടാതെ ആധുനിക IA-32 പ്രോസസ്സറുകൾക്കായി ജനറേറ്റ് ചെയ്ത കോഡിൽ വളരെ സാധാരണമായ ഒരു പ്രതിഭാസമായ ഇന്റർലീവ്ഡ് കോഡിന്റെ ഒരു ക്ലാസിക് കേസ് നിങ്ങൾ കാണുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is done to allow the highest level of parallelism during execution.","translation":"നടപ്പിലാക്കുമ്പോൾ ഏറ്റവും ഉയർന്ന തലത്തിലുള്ള സമാന്തരത അനുവദിക്കുന്നതിന് ഇത് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Following the comparison is another purely arithmetical application of the LEAinstruction.","translation":"താരതമ്യത്തെ തുടർന്ന് LEA നിർദ്ദേശത്തിന്റെ മറ്റൊരു കേവല ഗണിതപരമായ പ്രയോഗം വരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The code checks if EDX is not equal to zero and starts looping on elements.","translation":"EDX പൂജ്യത്തിനൊപ്പമല്ലെന്ന് കോഡ് പരിശോധിക്കുകയും, മൂലകങ്ങളിൽ ലൂപ്പ് ആരംഭിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This loop traverses the elements using offset +4 in each element.","translation":"ഓരോ മൂലകത്തിലും ഓഫ്‌സെറ്റ് +4 ഉപയോഗിച്ച് ഈ ലൂപ്പ് മൂലകങ്ങളിലൂടെ കടന്നുപോകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The number of iterations is stored in EDX.","translation":"ആവർത്തനങ്ങളുടെ എണ്ണം EDX-ൽ സംഭരിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This loop takes you the distance between the end of the list and the element you’re looking for.","translation":"ഈ ലൂപ്പ് നിങ്ങളെ ലിസ്റ്റിൻ്റെ അവസാനത്തിനും നിങ്ങൾ തിരയുന്ന മൂലകത്തിനും ഇടയിലുള്ള ദൂരത്തിലേക്ക് കൊണ്ടുപോകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This means that offset +4 in the root structure points to the last element in the list!","translation":"അതായത് റൂട്ട് ഘടനയിലെ ഓഫ്‌സെറ്റ് +4, ലിസ്റ്റിലെ അവസാന മൂലകത്തിലേക്ക് ചൂണ്ടുന്നു!","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"By taking offset +4 in each element you are going backward in the list toward the beginning.","translation":"ഓരോ മൂലകത്തിലും ഓഫ്‌സെറ്റ് +4 എടുക്കുന്നതിലൂടെ, നിങ്ങൾ ലിസ്റ്റിൽ പിന്നിലേക്ക്, തുടക്കത്തിലേക്ക് നീങ്ങുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"All RtlGetElementGenericTable is doing is it’s trying to find the right element in the lowest possible number of iterations.","translation":"RtlGetElementGenericTable ചെയ്യുന്നത് ഏറ്റവും കുറഞ്ഞ ആവർത്തനങ്ങളിൽ ശരിയായ മൂലകം കണ്ടെത്താൻ ശ്രമിക്കുകയാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"By the time EDX gets to zero, you know that you’ve found the element.","translation":"EDX പൂജ്യത്തിലെത്തുമ്പോൾ, നിങ്ങൾ മൂലകം കണ്ടെത്തിയെന്ന് നിങ്ങൾക്കറിയാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The code then flows into ntdll.7C96254E, which you’ve examined before.","translation":"തുടർന്ന് കോഡ് ntdll.7C96254E-ലേക്ക് ഒഴുകുന്നു, നിങ്ങൾ ഇത് മുമ്പ് പരിശോധിച്ചിട്ടുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is the code that caches the element you’ve found into offsets +c and +10 of the root data structure.","translation":"നിങ്ങൾ കണ്ടെത്തിയ മൂലകത്തെ റൂട്ട് ഡാറ്റാ ഘടനയുടെ ഓഫ്‌സെറ്റുകൾ +c, +10 എന്നിവയിലേക്ക് കാഷെ ചെയ്യുന്ന കോഡാണിത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"What happens when (in the previous sequence) EDI == 0, and the jump to ntdll.7C96254E is taken?","translation":"(മുമ്പത്തെ ശ്രേണിയിൽ) EDI == 0 ആകുമ്പോൾ, ntdll.7C96254E-ലേക്കുള്ള ജമ്പ് എടുക്കുമ്പോൾ എന്ത് സംഭവിക്കും?","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This simply skips the loop and goes straight to the caching of the found element.","translation":"ഇത് ലൂപ്പ് ഒഴിവാക്കുകയും കണ്ടെത്തിയ മൂലകത്തിന്റെ കാഷിംഗിലേക്ക് നേരിട്ട് പോവുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In this case, the function returns the previously found element.","translation":"ഈ സാഹചര്യത്തിൽ, ഫംഗ്ഷൻ മുമ്പ് കണ്ടെത്തിയ മൂലകം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"If neither of the previous two branches is taken, you know that EDI < EDX.","translation":"മുമ്പത്തെ രണ്ട് ബ്രാഞ്ചുകളും എടുത്തില്ലെങ്കിൽ, EDI < EDX ആണെന്ന് നിങ്ങൾക്കറിയാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In this case, you know that you must move forward in the list.","translation":"ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ ലിസ്റ്റിൽ മുന്നോട്ട് നീങ്ങണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The backward-searching loops you encountered earlier were both using offset +4 in the element’s header.","translation":"നിങ്ങൾ നേരത്തെ കണ്ട ബാക്ക്‌വേർഡ്-സെർച്ചിംഗ് ലൂപ്പുകൾ രണ്ടും മൂലകത്തിന്റെ ശീർഷകത്തിൽ ഓഫ്‌സെറ്റ് +4 ഉപയോഗിച്ചിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This one is using offset +0.","translation":"ഇതൊന്ന് ഓഫ്‌സെറ്റ് +0 ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"That’s really an easy one—this is clearly a linked list of some sort.","translation":"അത് ശരിക്കും എളുപ്പമുള്ള ഒന്നാണ് - ഇത് വ്യക്തമായും ഒരുതരം ലിങ്ക്ഡ് ലിസ്റ്റാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Also, this loop is using EDI as the counter.","translation":"കൂടാതെ, ഈ ലൂപ്പ് കൗണ്ടറായി EDI ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Remember how before we got into the first backward-searching loop we tested for a case where the index was lower than LastIndexFound / 2?","translation":"ആദ്യത്തെ ബാക്ക്‌വേർഡ്-സെർച്ചിംഗ് ലൂപ്പിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, സൂചിക LastIndexFound / 2-നേക്കാൾ കുറവായ ഒരു കേസ് ഞങ്ങൾ പരിശോധിച്ചത് ഓർക്കുക?","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This snippet loads offset +4 from the unknown structure in ESI and tests if it is zero.","translation":"ഈ കോഡ് ഭാഗം ESI-യിലെ അറിയപ്പെടാത്ത ഘടനയിൽ നിന്ന് ഓഫ്‌സെറ്റ് +4 ലോഡ് ചെയ്യുകയും അത് പൂജ്യമാണോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If it is nonzero, the code jumps to ntdll.7C924F22, a two-line segment that jumps back to ntdll.7C92148B.","translation":"അത് പൂജ്യമല്ലാത്തതാണെങ്കിൽ, കോഡ് ntdll.7C924F22-ലേക്ക് പോകുന്നു, ഇത് ntdll.7C92148B-യിലേക്ക് തിരികെ പോകുന്ന രണ്ട് വരികളുള്ള ഒരു ഭാഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is a bit more confusing than it could have been because of the way the function is scattered throughout the module.","translation":"മോഡ്യൂളിന്റെ വിവിധ ഭാഗങ്ങളിൽ ഫംഗ്ഷൻ ചിതറിക്കിടക്കുന്നതിനാൽ ഇത് അൽപ്പം ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If there is a nonzero value at that offset, the code loads that value into ESI and jumps back to ntdll.7C92148B, which is the callback calling code you just examined.","translation":"ആ ഓഫ്‌സെറ്റിൽ പൂജ്യമല്ലാത്ത ഒരു മൂല്യമുണ്ടെങ്കിൽ, കോഡ് ആ മൂല്യം ESI-ലേക്ക് ലോഡ് ചെയ്യുകയും നിങ്ങൾ ഇപ്പോൾ പരിശോധിച്ച കോൾബാക്ക് കോഡായ ntdll.7C92148B-ലേക്ക് തിരികെ പോവുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It looks like you’re looking at a loop that constantly calls into the callback and traverses some kind of linked list that starts at offset +0 of the root data structure.","translation":"കോൾബാക്കിലേക്ക് തുടർച്ചയായി വിളിക്കുകയും റൂട്ട് ഡാറ്റാ ഘടനയുടെ ഓഫ്‌സെറ്റ് +0-ൽ ആരംഭിക്കുന്ന ഒരു ലിങ്ക്ഡ് ലിസ്റ്റ് ട്രാക്ക് ചെയ്യുകയും ചെയ്യുന്ന ഒരു ലൂപ്പാണ് നിങ്ങൾ ഇപ്പോൾ കാണുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Each item seems to be at least 0x1c bytes long, because offset +18 of that structure is passed as the last parameter in the callback.","translation":"ഓരോ ഇനവും കുറഞ്ഞത് 0x1c ബൈറ്റുകളെങ്കിലും ഉണ്ടാകാൻ സാധ്യതയുണ്ട്, കാരണം ആ ഘടനയുടെ ഓഫ്‌സെറ്റ് +18 കോൾബാക്കിലെ അവസാന പാരാമീറ്ററായി കൈമാറുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s see what happens when the callback returns a nonzero value.","translation":"കോൾബാക്ക് പൂജ്യമല്ലാത്ത ഒരു മൂല്യം തിരികെ നൽകുമ്പോൾ എന്ത് സംഭവിക്കുമെന്ന് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"First of all, it seems that the callback returns some kind of a number and not a pointer.","translation":"ആദ്യം, കോൾബാക്ക് ഒരു പോയിന്ററല്ല, ഒരു സംഖ്യയാണ് നൽകുന്നതെന്ന് തോന്നുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This could be a Boolean, but you don’t know for sure yet.","translation":"ഇതൊരു ബൂളിയൻ ആയിരിക്കാം, എന്നാൽ നിങ്ങൾക്ക് ഇപ്പോഴും ഉറപ്പില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Notice how the second parameter is treated as a pointer, and that this pointer receives the current value of ESI, which is that unknown structure we discussed.","translation":"രണ്ടാമത്തെ പാരാമീറ്ററിനെ ഒരു പോയിന്ററായി കണക്കാക്കുന്നതും, ഈ പോയിന്റർ ESI-യുടെ നിലവിലെ മൂല്യം സ്വീകരിക്കുന്നതും ശ്രദ്ധിക്കുക, ഇത് നമ്മൾ ചർച്ച ചെയ്ത അജ്ഞാത ഘടനയാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Apparently, there is some kind of a linked list that starts at offset +0 in the root table data structure.","translation":"റൂട്ട് ടേബിൾ ഡാറ്റാ ഘടനയിലെ ഓഫ്‌സെറ്റ് +0-ൽ ആരംഭിക്കുന്ന ഒരുതരം ലിങ്ക്ഡ് ലിസ്റ്റ് ഉണ്ടെന്ന് തോന്നുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If the callback returns 0, the loop continues on offset +4 in the current item.","translation":"കോൾബാക്ക് 0 തിരികെ നൽകുകയാണെങ്കിൽ, ലൂപ്പ് നിലവിലെ ഇനത്തിലെ ഓഫ്‌സെറ്റ് +4-ൽ തുടരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If the callback returns 1, the function loads the next item from offset +8 in the current item.","translation":"കോൾബാക്ക് 1 തിരികെ നൽകുകയാണെങ്കിൽ, ഫംഗ്ഷൻ നിലവിലെ ഇനത്തിലെ ഓഫ്‌സെറ്റ് +8-ൽ നിന്ന് അടുത്ത ഇനം ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If the callback returns any other value, the loop terminates and the current item is returned.","translation":"കോൾബാക്ക് മറ്റേതെങ്കിലും മൂല്യം നൽകുകയാണെങ്കിൽ, ലൂപ്പ് അവസാനിപ്പിക്കുകയും നിലവിലെ ഇനം തിരികെ നൽകുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"What are we seeing here, what does this function do?","translation":"നമ്മൾ ഇവിടെ എന്താണ് കാണുന്നത്, ഈ ഫംഗ്ഷൻ എന്ത് ചെയ്യുന്നു?","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It’s hard to tell at this point, but the repeated callback calls and the direction changes based on the callback return values indicate that the callback might be used for determining the relative position of an element within the list.","translation":"ഇപ്പോൾ ഇത് പറയാൻ പ്രയാസമാണ്, എന്നാൽ ആവർത്തിച്ചുള്ള കോൾബാക്ക് കോളുകളും കോൾബാക്ക് റിട്ടേൺ മൂല്യങ്ങളെ ആശ്രയിച്ച് ദിശയിലുള്ള മാറ്റങ്ങളും, ലിസ്റ്റിനുള്ളിലെ ഒരു എലമെന്റിന്റെ ആപേക്ഷിക സ്ഥാനം നിർണ്ണയിക്കാൻ കോൾബാക്ക് ഉപയോഗിച്ചേക്കാം എന്ന് സൂചിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is probably defined as an element comparison callback that receives two elements and compares them.","translation":"ഇതൊരു എലമെന്റ് താരതമ്യ കോൾബാക്കായിരിക്കാം, ഇത് രണ്ട് ഘടകങ്ങൾ സ്വീകരിക്കുകയും അവയെ താരതമ്യം ചെയ്യുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If we were to draw on our previous conclusions regarding the arrangement of next and previous pointers we see that the next pointer comes first and is followed by the previous pointer.","translation":"അടുത്തതും, മുൻപത്തെയും പോയിന്ററുകളുടെ ക്രമീകരണത്തെക്കുറിച്ച് നമ്മൾ നേരത്തെ എടുത്ത നിഗമനങ്ങളിൽ എത്തിച്ചേരുകയാണെങ്കിൽ, അടുത്ത പോയിന്റർ ആദ്യം വരുന്നു, തുടർന്ന് മുൻ പോയിന്റർ വരുന്നു എന്ന് കാണാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"You’ve made good progress, but there are several pieces that just don’t seem to fit in.","translation":"നിങ്ങൾ നല്ല പുരോഗതി കൈവരിച്ചു, എന്നാൽ ചേരാത്ത ചില ഭാഗങ്ങൾ ഇപ്പോളുമുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"More likely, this is a tree structure of some sort, where offset +4 points to one side of the tree (let’s assume it’s the one with higher-valued elements), and offset +8 points to the other side.","translation":"കൂടുതൽ സാധ്യത, ഇതൊരുതരം ട്രീ ഘടനയാണ്, അവിടെ ഓഫ്‌സെറ്റ് +4 ട്രീയുടെ ഒരു വശത്തേക്കും (കൂടുതൽ മൂല്യമുള്ള ഘടകങ്ങളുള്ള ഒന്ന് എന്ന് കരുതുക), ഓഫ്‌സെറ്റ് +8 മറുവശത്തേക്കും ചൂണ്ടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The code sequence calls a function called RtlSplay.","translation":"RtlSplay എന്ന് പേരുള്ള ഒരു ഫംഗ്ഷനെ ഈ കോഡ് ശ്രേണി വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"RtlSplay takes one parameter.","translation":"RtlSplay ഒരു പാരാമീറ്റർ എടുക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The tree root pointer at pTable is set to the return value of RtlSplay.","translation":"pTable-ലെ ട്രീ റൂട്ട് പോയിന്റർ RtlSplay-യുടെ റിട്ടേൺ മൂല്യത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The code that follows checks for the optional Boolean pointer.","translation":"തുടർന്ന് വരുന്ന കോഡ്, ഓപ്ഷണൽ ബൂളിയൻ പോയിന്ററിനായി പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The function then loads the return value into EAX.","translation":"തുടർന്ന് ഫംഗ്ഷൻ EAX-ലേക്ക് റിട്ടേൺ മൂല്യം ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"RtlRealInsertElementWorker simply returns the pointer to the data of the newly allocated element.","translation":"RtlRealInsertElementWorker, പുതിയതായി അനുവദിച്ച എലമെന്റിന്റെ ഡാറ്റയിലേക്കുള്ള പോയിന്റർ തിരികെ നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The generic table is implemented using a splay tree.","translation":"ഒരു സ്പ്ലേ ട്രീ ഉപയോഗിച്ചാണ് ജെനറിക് ടേബിൾ നടപ്പിലാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Splay trees always rotate the most recently used item to the top of the tree.","translation":"സ്പ്ലേ ട്രീകൾ എപ്പോഴും ഏറ്റവും ഒടുവിൽ ഉപയോഗിച്ച ഇനത്തെ ട്രീയുടെ മുകളിലേക്ക് മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"RtlLookupElementGenericTable must be the one that provides some sort of search capabilities.","translation":"RtlLookupElementGenericTable ചിലതരം തിരയൽ ശേഷി നൽകുന്ന ഒന്നായിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s have a look at RtlLookupElementGenericTable.","translation":"RtlLookupElementGenericTable-ലേക്ക് ഒന്നു നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The first two parameters are the same parameters that were passed to RtlLookup ElementGenericTable.","translation":"ആദ്യത്തെ രണ്ട് പാരാമീറ്ററുകൾ RtlLookup ElementGenericTable-ലേക്ക് കൈമാറിയ അതേ പാരാമീറ്ററുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The compiler is simply using the stack area that was used for passing parameters into the function.","translation":"ഫംഗ്ഷനിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറാൻ ഉപയോഗിച്ച സ്റ്റാക്ക് ഏരിയയാണ് കംപൈലർ ഉപയോഗിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"RtlLocateNodeGenericTable is used for the actual locating of the element in question.","translation":"ചോദ്യം ചെയ്യപ്പെടുന്ന എലമെന്റ് കണ്ടെത്താൻ, RtlLocateNodeGenericTable ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Splay trees are always splayed after adding, removing, or searching for an element.","translation":"ഒരു എലമെന്റ് ചേർക്കുകയോ, നീക്കം ചെയ്യുകയോ, അല്ലെങ്കിൽ തിരയുകയോ ചെയ്ത ശേഷം സ്പ്ലേ ട്രീകൾ എപ്പോഴും വിന്യസിക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"RtlDeleteElementGenericTable has three primary steps.","translation":"RtlDeleteElementGenericTable-ന് പ്രധാനമായും മൂന്ന് ഘട്ടങ്ങളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It then calls the (exported) RtlDelete to actually remove the element.","translation":"തുടർന്ന്, എലമെന്റ് ശരിക്കും നീക്കം ചെയ്യാൻ (എക്സ്പോർട്ട് ചെയ്ത) RtlDelete-നെ വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The last function call made by RtlDeleteElementGenericTable is actually quite interesting.","translation":"RtlDeleteElementGenericTable നടത്തുന്ന അവസാനത്തെ ഫംഗ്ഷൻ കോൾ വളരെ രസകരമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It appears to be a callback into user code.","translation":"ഇതൊരു ഉപയോക്തൃ കോഡിലേക്കുള്ള കോൾബാക്ക് ആണെന്ന് തോന്നുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Whenever a reversing session of this magnitude is completed, it is advisable to prepare a little document that describes your findings.","translation":"ഇത്രയും വലിയൊരു റിവേഴ്സിംഗ് സെഷൻ പൂർത്തിയാകുമ്പോൾ, കണ്ടെത്തലുകൾ വിവരിക്കുന്ന ഒരു ചെറിയ ഡോക്യുമെന്റ് തയ്യാറാക്കുന്നത് നല്ലതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The secret is to always keep your eye on the big picture that’s slowly materializing in front of you while you’re reversing.","translation":"നിങ്ങൾ റിവേഴ്സ് ചെയ്യുമ്പോൾ, നിങ്ങളുടെ മുന്നിൽ സാവധാനം രൂപപ്പെടുന്ന വലിയ ചിത്രം എപ്പോഴും ശ്രദ്ധിക്കുക എന്നതാണ് രഹസ്യം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Cryptex is asking for the actual hash value.","translation":"യഥാർത്ഥ ഹാഷ് മൂല്യം നൽകാൻ ക്രൈപ്‌ടെക്സ് ആവശ്യപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The third parameter tells the function where to write the hash value.","translation":"മൂന്നാമത്തെ പരാമീറ്റർ, ഹാഷ് മൂല്യം എവിടെ എഴുതണം എന്ന് ഫംഗ്ഷനോട് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Cryptex is apparently hashing unknown, nontextual data.","translation":"ക്രൈപ്‌ടെക്സ്, തിരിച്ചറിയാത്ത, ടെക്സ്റ്റ് ഇതര ഡാറ്റ ഹാഷ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The contents of this global variable are later compared against a value stored in the Cryptex archive file.","translation":"ഈ ഗ്ലോബൽ വേരിയബിളിന്റെ ഉള്ളടക്കം പിന്നീട് ക്രൈപ്‌ടെക്സ് ആർക്കൈവ് ഫയലിൽ സംഭരിച്ചിട്ടുള്ള ഒരു മൂല്യവുമായി താരതമ്യം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If it isn’t identical, Cryptex reports an incorrect password.","translation":"അത് സമാനമല്ലെങ്കിൽ, തെറ്റായ പാസ്‌വേഡ് ആണെന്ന് ക്രൈപ്‌ടെക്സ് റിപ്പോർട്ട് ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is obvious that the data that is being hashed in the function from Listing 6.4 is clearly somehow related to the password that was typed.","translation":"ലിസ്റ്റിംഗ് 6.4-ൽ നിന്നുള്ള ഫംഗ്ഷനിൽ ഹാഷ് ചെയ്യുന്ന ഡാറ്റ, ടൈപ്പ് ചെയ്ത പാസ്‌വേർഡുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു എന്നത് വ്യക്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"We just don’t understand the connection.","translation":"ബന്ധമെന്തെന്ന് ഞങ്ങൾക്ക് മനസ്സിലാകുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The unknown data that was hashed in this function was passed as a parameter from the calling function.","translation":"ഈ ഫംഗ്ഷനിൽ ഹാഷ് ചെയ്ത, അറിയാത്ത ഡാറ്റ, കോളിംഗ് ഫംഗ്ഷനിൽ നിന്ന് ഒരു പാരാമീറ്ററായി കൈമാറി.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"At this point you’re probably a bit at a loss regarding the origin of the buffer.","translation":"ഈ ഘട്ടത്തിൽ, ബഫറിന്റെ ഉത്ഭവത്തെക്കുറിച്ച് നിങ്ങൾക്ക് ആശയക്കുഴപ്പമുണ്ടാകാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In such cases, it is usually best to simply trace back in the program until you find the origin of that buffer.","translation":"അത്തരം സന്ദർഭങ്ങളിൽ, ആ ബഫറിന്റെ ഉത്ഭവം കണ്ടെത്തുന്നതുവരെ പ്രോഗ്രാമിൽ പിന്നോട്ട് പോവുന്നതാണ് നല്ലത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In this case, the hashed buffer came from the calling function, at 00402300.","translation":"ഈ സാഹചര്യത്തിൽ, ഹാഷ് ചെയ്ത ബഫർ 00402300 എന്ന കോളിംഗ് ഫംഗ്ഷനിൽ നിന്നാണ് വന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This function is shown in Listing 6.5.","translation":"ഈ ഫംഗ്ഷൻ ലിസ്റ്റിംഗ് 6.5-ൽ കാണിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The Cryptex key-generation function.","translation":"ക്രൈപ്‌ടെക്സ് കീ ഉണ്ടാക്കുന്ന ഫംഗ്ഷൻ.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"SHA is another hashing algorithm that has similar properties to MD5.","translation":"MD5-ന് സമാനമായ പ്രോപ്പർട്ടികളുള്ള മറ്റൊരു ഹാഷിംഗ് അൽഗോരിതമാണ് SHA.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"You might notice that 160 bits are exactly 20 bytes, which is the length of data being hashed in Listing 6.4.","translation":"160 ബിറ്റുകൾ കൃത്യമായി 20 ബൈറ്റുകളാണ്, ഇത് ലിസ്റ്റിംഗ് 6.4-ൽ ഹാഷ് ചെയ്യുന്ന ഡാറ്റയുടെ നീളമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Coincidence? You’ll soon find out.","translation":"യാദൃശ്ചികതയാണോ? നിങ്ങൾ ഉടൻ കണ്ടെത്തും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"If you place a breakpoint on this function and restart the program, you can easily see which data it is that is being processed.","translation":"നിങ്ങൾ ഈ ഫംഗ്ഷനിൽ ഒരു ബ്രേക്ക്പോയിന്റ് വെച്ച് പ്രോഗ്രാം പുനരാരംഭിക്കുകയാണെങ്കിൽ, ഏത് ഡാറ്റയാണ് പ്രോസസ്സ് ചെയ്യപ്പെടുന്നതെന്ന് എളുപ്പത്തിൽ കാണാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It is the password text, which in this case equals 6666666665.","translation":"ഇത് പാസ്‌വേഡ് ടെക്സ്റ്റ് ആണ്, ഈ സാഹചര്യത്തിൽ 6666666665 ന് തുല്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This loop is really quite simple.","translation":"ഈ ലൂപ്പ് വളരെ ലളിതമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It reads each character from the string and checks whether its zero.","translation":"സ്‌ട്രിംഗിൽ നിന്ന് ഓരോ അക്ഷരവും വായിക്കുകയും അത് പൂജ്യമാണോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In most cases, the answer is to create simple, tiny files that contain known, easy-to-spot values.","translation":"ഏറ്റവും കൂടുതൽ കേസുകളിൽ, അറിയപ്പെടുന്നതും എളുപ്പത്തിൽ തിരിച്ചറിയാൻ കഴിയുന്നതുമായ മൂല്യങ്ങൾ അടങ്ങിയ ലളിതമായ ചെറിയ ഫയലുകൾ ഉണ്ടാക്കുക എന്നതാണ് ഇതിനുള്ള ഉത്തരം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This approach is very helpful, but it is not always going to be feasible.","translation":"ഈ സമീപനം വളരെ സഹായകമാണ്, പക്ഷേ ഇത് എല്ലായ്പ്പോഴും പ്രായോഗികമാകണമെന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"For example, with some file formats you might only have access to code that reads from the file, but not to the code that generates files using that format.","translation":"ഉദാഹരണത്തിന്, ചില ഫയൽ ഫോർമാറ്റുകളിൽ, ഫയലിൽ നിന്ന് റീഡ് ചെയ്യുന്ന കോഡിലേക്ക് നിങ്ങൾക്ക് പ്രവേശനം ഉണ്ടായിരിക്കാം, എന്നാൽ ആ ഫോർമാറ്റ് ഉപയോഗിച്ച് ഫയലുകൾ ഉണ്ടാക്കുന്ന കോഡിലേക്ക് പ്രവേശനം ഉണ്ടാകണമെന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This would greatly increase the complexity of the reversing process, because it would limit our options.","translation":"ഇത് റിവേഴ്സിംഗ് പ്രക്രിയയുടെ സങ്കീർണ്ണത വളരെയധികം വർദ്ധിപ്പിക്കും, കാരണം ഇത് നമ്മുടെ സാധ്യതകൾ പരിമിതപ്പെടുത്തും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In such cases, you would usually need to spend significant amounts of time studying the code that reads your file format.","translation":"അത്തരം സന്ദർഭങ്ങളിൽ, നിങ്ങളുടെ ഫയൽ ഫോർമാറ്റ് വായിക്കുന്ന കോഡ് പഠിക്കാൻ നിങ്ങൾ സാധാരണയായി ധാരാളം സമയം ചെലവഴിക്കേണ്ടിവരും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In most cases, a thorough analysis of such code would provide most of the answers.","translation":"മിക്ക കേസുകളിലും, അത്തരം കോഡിന്റെ സമഗ്രമായ വിശകലനം ഉത്തരങ്ങൾ നൽകും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Luckily, in this particular case Cryptex lets you create as many archives as you please, so you can freely experiment.","translation":"ഭാഗ്യവശാൽ, ഈ പ്രത്യേക കേസിൽ, നിങ്ങൾക്ക് ഇഷ്ടമുള്ളത്ര ആർക്കൈവുകൾ ഉണ്ടാക്കാൻ Cryptex നിങ്ങളെ അനുവദിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് സ്വതന്ത്രമായി പരീക്ഷണം നടത്താം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The best idea at this point would be to take a simple text file containing something like a long sequence of a single character such as “*****************************” and to encode it into an archive file.","translation":"ഈ ഘട്ടത്തിൽ ഏറ്റവും നല്ല ആശയം, “*****************************” പോലുള്ള ഒരൊറ്റ പ്രതീകത്തിന്റെ ഒരു നീണ്ട ശ്രേണി ഉൾക്കൊള്ളുന്ന ഒരു ലളിതമായ ടെക്സ്റ്റ് ഫയൽ എടുത്ത് അത് ഒരു ആർക്കൈവ് ഫയലിലേക്ക് എൻകോഡ് ചെയ്യുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Additionally, I would recommend trying out some long and repetitive password, to try and see if, God forbid, the password is somehow stored in the file.","translation":"കൂടാതെ, ദൈവം തമ്പുരാനെ, രഹസ്യവാക്ക് ഏതെങ്കിലും വിധത്തിൽ ഫയലിൽ സംഭരിച്ചിട്ടുണ്ടോ എന്ന് പരീക്ഷിക്കാൻ, ചില നീളമുള്ളതും ആവർത്തിച്ചുള്ളതുമായ രഹസ്യവാക്ക് പരീക്ഷിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It also makes sense to quickly scan the file for the original name of the encrypted file, to see if Cryptex encrypts the actual file table, or just the actual file contents.","translation":"Cryptex യഥാർത്ഥ ഫയൽ പട്ടിക എൻക്രിപ്റ്റ് ചെയ്യുന്നുണ്ടോ, അതോ യഥാർത്ഥ ഫയൽ ഉള്ളടക്കം മാത്രമാണോ എന്ന് അറിയാൻ, എൻക്രിപ്റ്റ് ചെയ്ത ഫയലിന്റെ യഥാർത്ഥ നാമം ഫയലിൽ വേഗത്തിൽ സ്കാൻ ചെയ്യുന്നതും നല്ലതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s start out by creating a tiny file called asterisks.txt, and fill it with a long sequence of asterisks (I created a file about 1K long).","translation":"asterisks.txt എന്ന് പേരുള്ള ഒരു ചെറിയ ഫയൽ ഉണ്ടാക്കി അതിൽ ആസ്റ്ററിസ്കുകളുടെ ഒരു നീണ്ട ശ്രേണി ചേർക്കാം (ഞാനൊരു 1K ഫയൽ ഉണ്ടാക്കി).","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Then proceed to creating a Cryptex archive that contains the asterisks.txtfile.","translation":"തുടർന്ന് asterisks.txt ഫയൽ അടങ്ങിയ ഒരു Cryptex ആർക്കൈവ് ഉണ്ടാക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Let’s use the string 6666666666as the password.","translation":"രഹസ്യവാക്കായി 6666666666 എന്ന സ്ട്രിംഗ് ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Cryptex provides the following feedback.","translation":"Cryptex താഴെ പറയുന്ന പ്രതികരണം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Interestingly, if you check the file size for Test1.crx, it is far larger than expected, at 8,248 bytes!","translation":"രസകരമെന്നു പറയട്ടെ, Test1.crx-ന്റെ ഫയൽ സൈസ് പരിശോധിച്ചാൽ, 8,248 ബൈറ്റിൽ കൂടുതൽ കാണാം!","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It looks as if Cryptex archives have quite a bit of overhead—you’ll soon see why that is.","translation":"Cryptex ആർക്കൈവുകൾക്ക് ധാരാളം ഓവർഹെഡ് ഉണ്ട് എന്ന് തോന്നുന്നു - എന്തുകൊണ്ടാണ് അങ്ങനെ സംഭവിക്കുന്നതെന്ന് നിങ്ങൾ ഉടൻ കാണും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Before actually starting to look inside the file, let’s ask Cryptex to show its contents, just to see how Cryptex views it.","translation":"യഥാർത്ഥത്തിൽ ഫയലിനുള്ളിൽ പ്രവേശിക്കുന്നതിന് മുമ്പ്, Cryptex-ന്റെ ഉള്ളടക്കം കാണിക്കാൻ ആവശ്യപ്പെടാം, ഇത് Cryptex എങ്ങനെയാണ് കാണുന്നതെന്ന് അറിയാൻ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"You can do this using the Lcommand in Cryptex, which lists the files con- tained in the given archive.","translation":"നൽകിയിട്ടുള്ള ആർക്കൈവിൽ അടങ്ങിയിട്ടുള്ള ഫയലുകൾ ലിസ്റ്റ് ചെയ്യുന്ന Cryptex-ലെ L കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Note that Cryptex requires the archive’s password on every command, including the list command.","translation":"ലിസ്റ്റ് കമാൻഡ് ഉൾപ്പെടെ എല്ലാ കമാൻഡുകളിലും Cryptex ആർക്കൈവിന്റെ രഹസ്യവാക്ക് ആവശ്യമാണ് എന്നത് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"There aren’t a whole lot of surprises in this output, but there’s one somewhat interesting point: the asterisks.txtfile was originally 1K and is shown here as being 3K long.","translation":"ഈ ഔട്ട്‌പുട്ടിൽ വലിയ അത്ഭുതങ്ങളൊന്നുമില്ല, എന്നാൽ ഒരു രസകരമായ പോയിന്റുണ്ട്: asterisks.txt ഫയൽ യഥാർത്ഥത്തിൽ 1K ആയിരുന്നു, ഇവിടെ 3K ആയി കാണിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The problem is that the cluster you were dealing with earlier was 4,104 bytes long, and here you’re dealing with clusters that are only 4,092 bytes long.","translation":"മുമ്പത്തെ ക്ലസ്റ്റർ 4,104 ബൈറ്റുകളുള്ളതായിരുന്നു, എന്നാൽ ഇപ്പോൾ നിങ്ങൾ കൈകാര്യം ചെയ്യുന്നത് 4,092 ബൈറ്റുകൾ മാത്രമുള്ള ക്ലസ്റ്ററുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The original number of clusters that you multiplied was taken from offset +8 in the current file entry structure, so you know that offset +8 contains the file size in clusters.","translation":"നിങ്ങൾ ഗുണിച്ച ക്ലസ്റ്ററുകളുടെ യഥാർത്ഥ സംഖ്യ നിലവിലെ ഫയൽ എൻട്രി ഘടനയിലെ ഓഫ്‌സെറ്റ് +8 ൽ നിന്നാണ് എടുത്തത്, അതിനാൽ ഓഫ്‌സെറ്റ് +8 ൽ ക്ലസ്റ്ററുകളിലെ ഫയൽ വലുപ്പം അടങ്ങിയിരിക്കുന്നു എന്ന് നിങ്ങൾക്കറിയാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This raises the question of where does Cryptex store the actual file size?","translation":"Cryptex യഥാർത്ഥ ഫയൽ വലുപ്പം എവിടെയാണ് സംഭരിക്കുന്നത് എന്ന ചോദ്യം ഇത് ഉയർത്തുന്നു?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It would not be possible to accurately recover encrypted files without creating them with the exact size they had originally.","translation":"തുടക്കത്തിൽ ഉണ്ടായിരുന്ന അതേ വലുപ്പത്തിൽ ഉണ്ടാക്കാതെ എൻക്രിപ്റ്റ് ചെയ്ത ഫയലുകൾ കൃത്യമായി വീണ്ടെടുക്കാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Therefore Cryptex must also maintain the accurate file size somewhere in the archive file.","translation":"അതുകൊണ്ട് തന്നെ ആർക്കൈവ് ഫയലിൽ എവിടെയെങ്കിലും കൃത്യമായ ഫയൽ വലുപ്പം Cryptex നിലനിർത്തണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Other than the file size, the printf call also takes the file name, which is easily obtained by taking the address of offset +14 from ESI.","translation":"ഫയൽ വലുപ്പത്തിനു പുറമെ, പ്രിന്റ്ഫ് കോൾ ഫയൽ നാമവും എടുക്കുന്നു, ഇത് ESI-യിൽ നിന്ന് ഓഫ്‌സെറ്റ് +14-ൻ്റെ വിലാസം എടുത്താൽ എളുപ്പത്തിൽ ലഭിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Keep in mind that ESI was incremented by 8 earlier, so this is actually offset +1C from the original data structure, which matches what you saw in our data dump, where the string started at offset +1C.","translation":"ESI മുമ്പ് 8-ആയി വർദ്ധിപ്പിച്ചു എന്നത് ഓർമ്മിക്കുക, അതിനാൽ ഇത് യഥാർത്ഥ ഡാറ്റാ ഘടനയിൽ നിന്നുള്ള ഓഫ്‌സെറ്റ് +1C ആണ്, ഇത് ഞങ്ങളുടെ ഡാറ്റാ ഡംപിൽ നിങ്ങൾ കണ്ടതുമായി പൊരുത്തപ്പെടുന്നു, അവിടെ സ്ട്രിംഗ് ഓഫ്‌സെറ്റ് +1C-ൽ ആരംഭിച്ചു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"After printing the file name and size, the program loops back to print the next entry.","translation":"ഫയൽ നാമവും വലുപ്പവും പ്രിന്റ് ചെയ്ത ശേഷം, പ്രോഗ്രാം അടുത്ത എൻട്രി പ്രിന്റ് ചെയ്യാൻ വീണ്ടും പ്രവർത്തിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"To reach the next item, Cryptex increments ESI by 0x98 bytes (152 in decimal), which is clearly the length of each entry.","translation":"അടുത്ത ഇനത്തിലേക്ക് എത്താൻ, Cryptex ESI 0x98 ബൈറ്റുകൾ (ദശാംശത്തിൽ 152) വർദ്ധിപ്പിക്കുന്നു, ഇത് ഓരോ എൻട്രിയുടെയും നീളമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This indicates that there is a fixed number of characters reserved for each file name.","translation":"ഓരോ ഫയൽ നാമത്തിനും ഒരു നിശ്ചിത എണ്ണം പ്രതീകങ്ങൾ സംവരണം ചെയ്തിട്ടുണ്ടെന്ന് ഇത് സൂചിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Since you know that the string starts at offset +14 in the structure, you can assume that there aren’t any additional data entries after it in the structure, which would mean that the maximum length of a file name in Cryptex is 152 – 20, or 132 bytes.","translation":"നിങ്ങൾക്കറിയാവുന്നതുപോലെ, സ്ട്രിംഗ് ഘടനയിൽ ഓഫ്‌സെറ്റ് +14-ൽ ആരംഭിക്കുന്നു, അതിനുശേഷം ഘടനയിൽ അധിക ഡാറ്റാ എൻട്രികളൊന്നും ഉണ്ടാകില്ലെന്ന് നിങ്ങൾക്ക് അനുമാനിക്കാം, അതായത് Cryptex-ലെ ഒരു ഫയൽ നാമത്തിന്റെ പരമാവധി നീളം 152 – 20, അല്ലെങ്കിൽ 132 ബൈറ്റുകൾ ആയിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Once this loop ends, an interesting thing takes place.","translation":"ഈ ലൂപ്പ് അവസാനിക്കുമ്പോൾ, രസകരമായ ഒന്ന് സംഭവിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The first member in the buffer you read and decrypted earlier is tested, and if it is nonzero, Cryptex calls the function at 00401030, the function from Listing 6.7 that reads and decrypts a data chunk that we analyzed earlier.","translation":"നിങ്ങൾ നേരത്തെ വായിച്ച് ഡീക്രിപ്റ്റ് ചെയ്ത ബഫറിലെ ആദ്യ അംഗത്തെ പരിശോധിക്കുന്നു, കൂടാതെ അത് ശൂന്യമല്ലാത്തതാണെങ്കിൽ, Cryptex 00401030 എന്ന ഫംഗ്ഷൻ വിളിക്കുന്നു, ഇത് നമ്മൾ നേരത്തെ വിശകലനം ചെയ്ത ഒരു ഡാറ്റാ ഭാഗം വായിക്കുകയും ഡീക്രിപ്റ്റ് ചെയ്യുകയും ചെയ്യുന്ന ലിസ്റ്റിംഗ് 6.7-ൽ നിന്നുള്ള ഫംഗ്ഷനാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Clearly the idea here is to read and decrypt another chunk of data and scan it for files.","translation":"ഇവിടെയുള്ള ആശയം, മറ്റൊരു ഡാറ്റാ ഭാഗം വായിച്ച് ഡീക്രിപ്റ്റ് ചെയ്യുകയും അതിലെ ഫയലുകൾ സ്കാൻ ചെയ്യുകയുമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It looks likes the file list can span an arbitrary number clusters and is essentially implemented using a sort of cluster linked list.","translation":"ഫയൽ ലിസ്റ്റ്, ഇഷ്ടമുള്ളത്ര ക്ലസ്റ്ററുകളിൽ വ്യാപിക്കാനും, ഒരുതരം ക്ലസ്റ്റർ ലിങ്ക്ഡ് ലിസ്റ്റ് ഉപയോഗിച്ച് നടപ്പിലാക്കാനും സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This brings up one question: Is the first cluster hard-coded to number one?","translation":"ഇതൊരു ചോദ്യം ഉയർത്തുന്നു: ആദ്യത്തെ ക്ലസ്റ്റർ ഒന്നെന്ന് ഹാർഡ് കോഡ് ചെയ്തിരിക്കുകയാണോ?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The first-cluster index is taken from a global variable with a familiar address.","translation":"ആദ്യ ക്ലസ്റ്റർ സൂചിക, പരിചിതമായ വിലാസമുള്ള ഒരു ഗ്ലോബൽ വേരിയബിളിൽ നിന്നാണ് എടുക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"So, it looks like offset +0C in the Cryptex header contains the index of the first cluster in the file table.","translation":"അതുകൊണ്ട്, Cryptex ശീർഷകത്തിലെ ഓഫ്‌സെറ്റ് +0C-ൽ ഫയൽ പട്ടികയിലെ ആദ്യ ക്ലസ്റ്ററിൻ്റെ സൂചിക അടങ്ങിയിരിക്കുന്നതായി തോന്നുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"You now know that the first member in these file table clusters is the next cluster element that tells Cryptex which cluster contains the following file table entries, if any.","translation":"ഈ ഫയൽ ടേബിൾ ക്ലസ്റ്ററുകളിലെ ആദ്യ അംഗം, Cryptex-നോട്, ഏതെങ്കിലും ഫയൽ ടേബിൾ എൻട്രികൾ അടങ്ങിയിട്ടുള്ള ക്ലസ്റ്റർ ഏതാണെന്ന് പറയുന്ന അടുത്ത ക്ലസ്റ്റർ ഘടകമാണെന്ന് നിങ്ങൾ ഇപ്പോൾക്കറിയാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Because the size of each file entry is fixed, there must also be a fixed number of entries in each cluster.","translation":"ഓരോ ഫയൽ എൻട്രിയുടെയും വലുപ്പം നിശ്ചിതമായിരിക്കുന്നതിനാൽ, ഓരോ ക്ലസ്റ്ററിലും നിശ്ചിത എണ്ണം എൻട്രികൾ ഉണ്ടായിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The program treats any negative value as a very large number.","translation":"പ്രോഗ്രാം ഏതെങ്കിലും നെഗറ്റീവ് മൂല്യത്തെ വളരെ വലിയ സംഖ്യയായി കണക്കാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Integer overflows can occur in various ways.","translation":"പല തരത്തിൽ പൂർണ്ണസംഖ്യാ ഒഴുക്കുകൾ സംഭവിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Consider a scenario where the buffer length is modified.","translation":"ബഫർ നീളം പരിഷ്കരിക്കുന്ന ഒരു സാഹചര്യം പരിഗണിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Attackers can exploit integer overflows to create buffer overflows.","translation":"ആക്രമണകാരികൾക്ക് ബഫർ ഓവർഫ്ലോകൾ സൃഷ്ടിക്കാൻ പൂർണ്ണസംഖ്യാ ഒഴുക്കുകൾ മുതലെടുക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The code adds a constant to the user-supplied length.","translation":"കോഡ് ഉപയോക്താവ് നൽകിയ നീളത്തിലേക്ക് ഒരു സ്ഥിരമായ സംഖ്യ ചേർക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This can lead to significant security risks.","translation":"ഇത് സുരക്ഷാപരമായ അപകടങ്ങൾക്ക് കാരണമായേക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The function allocates a buffer of a specific length.","translation":"പ്രവർത്തനം ഒരു പ്രത്യേക നീളമുള്ള ഒരു ബഫർ അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The return value is the pointer of the newly allocated block.","translation":"പുതിയതായി അനുവദിച്ച ബ്ലോക്കിന്റെ പോയിന്റാണ് റിട്ടേൺ മൂല്യം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The buffer is initialized and the user-supplied data is copied.","translation":"ബഫർ ആരംഭിക്കുകയും ഉപയോക്താവ് നൽകിയ ഡാറ്റ പകർത്തുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The problem arises from the arithmetic operation on the buffer length.","translation":"ബഫർ നീളത്തിലുള്ള ഗണിത പ്രവർത്തനത്തിൽ നിന്നാണ് പ്രശ്നം ഉണ്ടാകുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"A very high value in EDI can cause an overflow.","translation":"EDI-യിലെ വളരെ ഉയർന്ന മൂല്യം ഒരു ഓവർഫ്ലോയ്ക്ക് കാരണമാകും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The addition could overflow, resulting in a low positive number.","translation":"കൂട്ടിച്ചേർക്കൽ ഓവർഫ്ലോ ഉണ്ടാക്കുകയും, കുറഞ്ഞ പോസിറ്റീവ് സംഖ്യക്ക് കാരണമാകുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The processor truncates the result.","translation":"പ്രോസസ്സർ ഫലം വെട്ടിച്ചുരുക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The function would crash because of the overflow.","translation":"ഓവർഫ്ലോ കാരണം ഫംഗ്ഷൻ തകരും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The solution is to limit the input size.","translation":"ഇൻപുട്ട് വലുപ്പം പരിമിതപ്പെടുത്തുക എന്നതാണ് ഇതിനുള്ള പരിഹാരം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Using an unsigned short for the buffer length solves the problem.","translation":"ബഫർ നീളത്തിനായി ഒപ്പിടാത്ത ഷോർട്ട് ഉപയോഗിക്കുന്നത് പ്രശ്നം പരിഹരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Type conversion errors can lead to vulnerabilities.","translation":"ടൈപ്പ് കൺവേർഷൻ പിശകുകൾക്ക് സുരക്ഷാ പ്രശ്നങ്ങളിലേക്ക് നയിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Developers may mishandle incoming data types.","translation":"ഡെവലപ്പർമാർക്ക് ഇൻകമിംഗ് ഡാറ്റാ ടൈപ്പുകൾ കൈകാര്യം ചെയ്യുന്നതിൽ തെറ്റ് പറ്റാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The compiler might not handle integers as expected.","translation":"കണക്കുകൂട്ടൽ രീതി ശരിയായി പ്രവർത്തിച്ചെന്ന് വരില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The MOVSX instruction can cause sign extension.","translation":"MOVSX നിർദ്ദേശം ചിഹ്ന വിപുലീകരണത്തിന് കാരണമായേക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The function receives variable-length input from the outside world into that buffer.","translation":"പുറത്ത് നിന്നുള്ള വേരിയബിൾ-ലെങ്ത് ഇൻപുട്ട് ആ ഫംഗ്ഷൻ ആ ബഫറിലേക്ക് സ്വീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The classic case is a function that receives a null-terminated string as input.","translation":"ഒരു ശൂന്യമായ ടെർമിനേറ്റഡ് സ്ട്രിംഗ് ഇൻപുട്ടായി സ്വീകരിക്കുന്ന ഒരു ഫംഗ്ഷനാണ് ക്ലാസിക് കേസ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Here is an example that was disassembled using WinDbg.","translation":"വിൻഡിബഗ് ഉപയോഗിച്ച് ഡിസ്അസംബിൾ ചെയ്ത ഒരു ഉദാഹരണം ഇതാ.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Before dealing with the specifics of the overflow bug in this code, let’s try to figure out the basics of this function.","translation":"ഈ കോഡിലെ ഓവർഫ്ലോ ബഗിന്റെ പ്രത്യേകതകൾ കൈകാര്യം ചെയ്യുന്നതിന് മുമ്പ്, ഈ ഫംഗ്ഷന്റെ അടിസ്ഥാനകാര്യങ്ങൾ കണ്ടെത്താൻ ശ്രമിക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The function was defined with the cdecl calling convention, so the parameters are unwound by the caller.","translation":"cdecl കോളിംഗ് കൺവെൻഷൻ ഉപയോഗിച്ചാണ് ഫംഗ്ഷൻ നിർവചിച്ചിരിക്കുന്നത്, അതിനാൽ പരാമീറ്ററുകൾ കോളർ അൺവൈൻഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Let’s try to figure out the stack layout in this function.","translation":"ഈ ഫംഗ്ഷനിലെ സ്റ്റാക്ക് ലേഔട്ട് കണ്ടെത്താൻ ശ്രമിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Start by reading a parameter from [esp+0x4], and then subtract ESP by 100 bytes, to make room for local variables.","translation":"[esp+0x4]-ൽ നിന്ന് ഒരു പാരാമീറ്റർ വായിച്ച് ആരംഭിച്ച്, ലോക്കൽ വേരിയബിളുകൾക്കായി ഇടം നൽകുന്നതിന് ESP-യിൽ നിന്ന് 100 ബൈറ്റുകൾ കുറയ്ക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If you go to the end of the function, you’ll see the code that moves ESP back to where it was when I first entered the function.","translation":"നിങ്ങൾ ഫംഗ്ഷന്റെ അവസാനം വരെ പോയാൽ, ഞാൻ ആദ്യമായി ഫംഗ്ഷനിൽ പ്രവേശിച്ചപ്പോൾ ESP എവിടെയായിരുന്നോ, അവിടേക്ക് മാറ്റുന്ന കോഡ് കാണാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is the add esp, 0x78, but why is it adding 120 bytes instead of 100?","translation":"ഇത് add esp, 0x78 ആണ്, എന്നാൽ 100 ബൈറ്റുകൾക്ക് പകരം 120 ബൈറ്റുകൾ എന്തുകൊണ്ട് ചേർക്കുന്നു?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If you look at the function, you’ll see three function calls to strcpy, strcat, and system.","translation":"നിങ്ങൾ ഫംഗ്ഷൻ പരിശോധിച്ചാൽ, strcpy, strcat, system എന്നിവയിലേക്കുള്ള മൂന്ന് ഫംഗ്ഷൻ കോളുകൾ കാണാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In this function, instead of adding an add esp, NumberOfBytes after each call, the compiler has chosen to optimize the unwinding process by simply unwinding the parameters from all three function calls at once.","translation":"ഈ ഫംഗ്ഷനിൽ, ഓരോ കോളിനും ശേഷം add esp, NumberOfBytes ചേർക്കുന്നതിനുപകരം, എല്ലാ മൂന്ന് ഫംഗ്ഷൻ കോളുകളിൽ നിന്നുമുള്ള പാരാമീറ്ററുകൾ ഒരേസമയം അൺവൈൻഡ് ചെയ്യുന്നതിലൂടെ കംപൈലർ അൺവൈൻഡിംഗ് പ്രക്രിയ ഒപ്റ്റിമൈസ് ചെയ്യാൻ തിരഞ്ഞെടുത്തിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This approach makes for a slightly less “reverser-friendly” function because every time the stack is accessed through ESP, you have to try to figure out where ESP is pointing to for each instruction.","translation":"ഈ സമീപനം അൽപ്പം കുറഞ്ഞ “റിവേഴ്സർ-ഫ്രണ്ട്ലി” ഫംഗ്ഷനായി മാറുന്നു, കാരണം ESP വഴി സ്റ്റാക്ക് ആക്സസ് ചെയ്യുമ്പോഴെല്ലാം, ഓരോ നിർദ്ദേശത്തിനും ESP എവിടെയാണ് ചൂണ്ടിക്കാണിക്കുന്നതെന്ന് നിങ്ങൾ കണ്ടെത്താൻ ശ്രമിക്കണം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"From the program’s perspective, the unwinding of the stack at the end of the function has another disadvantage: The function ends up using a bit more stack space.","translation":"പ്രോഗ്രാമിന്റെ വീക്ഷണകോണിൽ നിന്ന്, ഫംഗ്ഷന്റെ അവസാനം സ്റ്റാക്ക് അൺവൈൻഡ് ചെയ്യുന്നതിന് മറ്റൊരു ദോഷമുണ്ട്: ഫംഗ്ഷൻ അൽപ്പം കൂടുതൽ സ്റ്റാക്ക് ഇടം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"So, what do each of the ESP references in this function access?","translation":"അപ്പോൾ, ഈ ഫംഗ്ഷനിലെ ഓരോ ESP റഫറൻസുകളും എന്തിനാണ് ആക്സസ് ചെയ്യുന്നത്?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If you look closely, you’ll see that other than the first access at [esp+0x4], the last three stack accesses are all going to the same place.","translation":"[esp+0x4]-ൽ ആദ്യ ആക്സസ് ഒഴികെ, അവസാനത്തെ മൂന്ന് സ്റ്റാക്ക് ആക്സസുകളും ഒരേ സ്ഥലത്തേക്കാണ് പോകുന്നതെന്ന് സൂക്ഷ്മമായി പരിശോധിച്ചാൽ കാണാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The function starts by copying a string whose pointer was passed as the first parameter to a local variable (whose size we know is 100 bytes).","translation":"ആദ്യത്തെ പാരാമീറ്ററായി പാസ് ചെയ്ത ഒരു സ്ട്രിംഗ്, ഒരു ലോക്കൽ വേരിയബിളിലേക്ക് (അതിന്റെ വലുപ്പം 100 ബൈറ്റാണെന്ന് നമുക്കറിയാം) പകർത്തിയാണ് ഫംഗ്ഷൻ ആരംഭിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is exactly where the potential stack overflow lies.","translation":"സാധ്യതയുള്ള സ്റ്റാക്ക് ഓവർഫ്ലോ ഉണ്ടാകുന്നത് ഇവിടെയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"strcpy has no idea how big a buffer has been reserved for the copied string and will keep on copying until it encounters the null terminator in the source string or until the program crashes.","translation":"പകർത്തുന്ന സ്ട്രിംഗിനായി എത്ര വലിയ ബഫറാണ് റിസർവ് ചെയ്തിരിക്കുന്നതെന്ന് strcpy-ക്ക് അറിയില്ല, കൂടാതെ സോഴ്സ് സ്ട്രിംഗിലെ നൾ ടെർമിനേറ്റർ കണ്ടെത്തുന്നതുവരെ അല്ലെങ്കിൽ പ്രോഗ്രാം ക്രാഷ് ആകുന്നത് വരെ ഇത് പകർത്തിക്കൊണ്ടേയിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If a string longer than 100 bytes is fed to this function, strcpy will essentially overwrite whatever follows the local string variable in the stack.","translation":"100 ബൈറ്റിൽ കൂടുതൽ നീളമുള്ള ഒരു സ്ട്രിംഗ് ഈ ഫംഗ്ഷനിലേക്ക് നൽകിയാൽ, സ്റ്റാക്കിലെ ലോക്കൽ സ്ട്രിംഗ് വേരിയബിളിന് ശേഷം വരുന്നവയെല്ലാം strcpy തിരുത്തിയെഴുതും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Overwriting the return address is a sure way of gaining control of the system.","translation":"റിട്ടേൺ വിലാസം തിരുത്തിയെഴുതുന്നത് സിസ്റ്റത്തിന്റെ നിയന്ത്രണം നേടുന്നതിനുള്ള ഉറപ്പായ വഴിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"A trained eye immediately recognizes that it is conspicuously similar to the value of 2 32 : 4,294,967,296.","translation":"പരിശീലനം ലഭിച്ച ഒരു കണ്ണിന് ഇത് 2 32 ന്റെ മൂല്യവുമായി വളരെ സാമ്യമുള്ളതാണെന്ന് ഉടനടി മനസ്സിലാകും: 4,294,967,296.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is in fact not similar, but identical to 2 32 .","translation":"വാസ്തവത്തിൽ ഇത് സമാനമല്ല, 2 32 ന് തുല്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The idea here is quite simple.","translation":"ഇവിടെയുള്ള ആശയം വളരെ ലളിതമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Apparently FILD always treats the integers as signed, but the original program declared an unsigned integer that was to be converted into a floating- point form.","translation":"FILD എപ്പോഴും പൂർണ്ണസംഖ്യകളെ ചിഹ്നമുള്ളവയായി കണക്കാക്കുന്നു, എന്നാൽ യഥാർത്ഥ പ്രോഗ്രാം ഒരു ചിഹ്നമില്ലാത്ത പൂർണ്ണസംഖ്യയെയാണ് പ്രഖ്യാപിച്ചത്, അത് ഫ്ലോട്ടിംഗ്-പോയിന്റ് രൂപത്തിലേക്ക് മാറ്റേണ്ടതായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"To force the CPU to always treat these values as signed the compiler generated code that adds 2 32 to the variable if it has its most significant bit set.","translation":"ഈ മൂല്യങ്ങളെ എപ്പോഴും ചിഹ്നമുള്ളവയായി കണക്കാക്കാൻ CPU-വിനെ നിർബന്ധിക്കുന്നതിന്, ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റ് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ വേരിയബിളിലേക്ക് 2 32 ചേർക്കുന്ന കോഡ് കംപൈലർ ഉണ്ടാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"After correcting the loaded number, Cryptex uses the FDIVR instruction to divide a constant from 00403B98by the number from the top of the floating- point stack.","translation":"ലോഡ് ചെയ്ത നമ്പർ തിരുത്തിയ ശേഷം, ഫ്ലോട്ടിംഗ്-പോയിന്റ് സ്റ്റാക്കിന്റെ മുകളിൽ നിന്നുള്ള സംഖ്യ ഉപയോഗിച്ച് 00403B98ൽ നിന്നുള്ള ഒരു സ്ഥിരസംഖ്യയെ വിഭജിക്കാൻ Cryptex FDIVR നിർദ്ദേശം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This time the number is a 64-bit floating-point number (according to the Intel documentation), so you can ask OllyDbg to dump data starting at 00403B98as 64-bit floating point.","translation":"ഇത്തവണ സംഖ്യ ഒരു 64-ബിറ്റ് ഫ്ലോട്ടിംഗ്-പോയിന്റ് സംഖ്യയാണ് (ഇന്റൽ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്), അതിനാൽ 00403B98-ൽ ആരംഭിച്ച് 64-ബിറ്റ് ഫ്ലോട്ടിംഗ് പോയിന്റായി ഡാറ്റ നൽകാൻ നിങ്ങൾക്ക് OllyDbg-യോട് ആവശ്യപ്പെടാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Olly displays 100.0000000000000, which means that Cryptex is dividing 100.0 by the total number of clusters.","translation":"Cryptex 100.0 നെ ക്ലസ്റ്ററുകളുടെ എണ്ണം കൊണ്ട് ഹരിക്കുന്നു എന്ന് Olly 100.0000000000000 എന്ന് കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The next instruction loads the file name address from [ESP+24]to EAXand proceeds to another unusual instruction called XORPS, which takes an unusual operand called XMM0.","translation":"[ESP+24]-ൽ നിന്ന് ഫയൽ നാമ വിലാസം EAX-ലേക്ക് ലോഡ് ചെയ്യുന്ന അടുത്ത നിർദ്ദേശം XORPS എന്ന മറ്റൊരു അസാധാരണ നിർദ്ദേശത്തിലേക്ക് പോകുന്നു, ഇത് XMM0 എന്ന അസാധാരണ ഓപ്പറാൻ്റ് എടുക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is part of a completely separate instruction set called SSE2 that is supported by most currently available implementations of IA-32 processors.","translation":"ഇത് SSE2 എന്ന് വിളിക്കപ്പെടുന്ന പൂർണ്ണമായും വ്യത്യസ്തമായ ഒരു ഇൻസ്ട്രക്ഷൻ സെറ്റിന്റെ ഭാഗമാണ്, ഇത് നിലവിൽ ലഭ്യമായ IA-32 പ്രോസസ്സറുകളുടെ മിക്ക നടപ്പിലാക്കലുകളും പിന്തുണയ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The SSE2 instruction set contains Single Instruction Multiple Data (SIMD) instructions that can operate on several groups of operands at the same time.","translation":"SSE2 ഇൻസ്ട്രക്ഷൻ സെറ്റിൽ ഒരേ സമയം ഒന്നിലധികം ഓപ്പറാൻ്റുകളുടെ ഗ്രൂപ്പുകളിൽ പ്രവർത്തിക്കാൻ കഴിയുന്ന സിംഗിൾ ഇൻസ്ട്രക്ഷൻ മൾട്ടിപ്പിൾ ഡാറ്റ (SIMD) നിർദ്ദേശങ്ങൾ അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This can create significant performance boosts for computationally intensive programs such as multimedia and content creation applications.","translation":"മൾട്ടിമീഡിയ, ഉള്ളടക്ക സൃഷ്ടിക്കൽ ആപ്ലിക്കേഷനുകൾ പോലുള്ള കമ്പ്യൂട്ടേഷണൽ തീവ്രമായ പ്രോഗ്രാമുകൾക്ക് ഇത് കാര്യമായ പ്രകടനം നൽകും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"XMM0is the first of 8 special, 128-bit registers names: XMM0through XMM7.","translation":"XMM0 എന്നത് 8 പ്രത്യേക, 128-ബിറ്റ് രജിസ്റ്ററുകളുടെ ആദ്യത്തേതാണ്: XMM0 മുതൽ XMM7 വരെ.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"These registers can only be accessed using SSE instructions, and their contents are usually made up of several smaller operands.","translation":"ഈ രജിസ്റ്ററുകൾ SSE നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് മാത്രമേ ആക്സസ് ചെയ്യാൻ കഴിയൂ, കൂടാതെ അവയുടെ ഉള്ളടക്കങ്ങൾ സാധാരണയായി നിരവധി ചെറിയ ഓപ്പറാൻ്റുകൾ ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In this particular case, the XORPS instruction XORs the entire contents of the first SSE register with the second SSE register.","translation":"ഈ പ്രത്യേക കേസിൽ, XORPS നിർദ്ദേശം ആദ്യത്തെ SSE രജിസ്റ്ററിലെ എല്ലാ ഉള്ളടക്കങ്ങളെയും രണ്ടാമത്തെ SSE രജിസ്റ്ററുമായി XOR ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Because XORPSis XORing a value with itself, it is essentially set- ting the value of XMM0to zero.","translation":"XORPS ഒരു മൂല്യത്തെ സ്വയം XOR ചെയ്യുന്നതിനാൽ, ഇത് XMM0-ന്റെ മൂല്യം പൂജ്യമായി സജ്ജമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The FSTPinstruction that comes next stores the value from the top of the floating-point stack into [ESP+34].","translation":"അടുത്തതായി വരുന്ന FSTP നിർദ്ദേശം ഫ്ലോട്ടിംഗ്-പോയിന്റ് സ്റ്റാക്കിന്റെ മുകളിലുള്ള മൂല്യം [ESP+34]-ലേക്ക് സംഭരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"As you can see from the DWORD PTRthat precedes the address, the instruction treats the memory address as a 32-bit location, and will convert the value to a 32-bit floating-point representation.","translation":"വിലാസത്തിന് മുന്നിലുള്ള DWORD PTR-ൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, നിർദ്ദേശം മെമ്മറി വിലാസത്തെ ഒരു 32-ബിറ്റ് സ്ഥാനമായി കണക്കാക്കുകയും മൂല്യത്തെ 32-ബിറ്റ് ഫ്ലോട്ടിംഗ്-പോയിന്റ് പ്രാതിനിധ്യത്തിലേക്ക് മാറ്റുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"As a reminder, the value currently stored at the top of the floating-point stack is the result of the earlier division operation.","translation":"ഒരു ഓർമ്മപ്പെടുത്തൽ എന്ന നിലയിൽ, നിലവിൽ ഫ്ലോട്ടിംഗ്-പോയിന്റ് സ്റ്റാക്കിന്റെ മുകളിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യം, നേരത്തെയുള്ള ഡിവിഷൻ പ്രവർത്തനത്തിന്റെ ഫലമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"At this point, we enter into what is clearly a loop that continuously reads and decrypts additional clusters using 00401030, hashes that data using CryptHashData, and writes the block to the file that was opened earlier using the WriteFileAPI.","translation":"ഈ ഘട്ടത്തിൽ, 00401030 ഉപയോഗിച്ച് തുടർച്ചയായി അധിക ക്ലസ്റ്ററുകൾ വായിക്കുകയും ഡീക്രിപ്റ്റ് ചെയ്യുകയും, CryptHashData ഉപയോഗിച്ച് ആ ഡാറ്റയെ ഹാഷ് ചെയ്യുകയും, WriteFileAPI ഉപയോഗിച്ച് മുമ്പ് തുറന്ന ഫയലിലേക്ക് ബ്ലോക്ക് എഴുതുകയും ചെയ്യുന്ന ഒരു ലൂപ്പിലേക്ക് നമ്മൾ പ്രവേശിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Security holes can be elusive and hard to define.","translation":"സുരക്ഷാ വിള്ളലുകൾ കണ്ടെത്താനും നിർവചിക്കാനും പ്രയാസകരമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The fact is that even with source code it can sometimes be difficult to distinguish safe, harmless code from dangerous security vulnerabilities.","translation":"സോഴ്സ് കോഡ് ഉണ്ടായിരുന്നാൽ പോലും സുരക്ഷിതവും ദോഷകരമല്ലാത്തതുമായ കോഡിനെ അപകടകരമായ സുരക്ഷാ പ്രശ്നങ്ങളിൽ നിന്ന് വേർതിരിക്കുന്നത് ചിലപ്പോൾ ബുദ്ധിമുട്ടാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Still, when you know what type of problems you’re looking for and you have certain code areas that you know are high risk, it is definitely possible to estimate whether a given function is safe or not by reversing it.","translation":"എങ്കിലും, നിങ്ങൾ എന്ത് തരത്തിലുള്ള പ്രശ്നങ്ങളാണ് അന്വേഷിക്കുന്നതെന്നും, ഉയർന്ന അപകടസാധ്യതയുള്ള ചില കോഡ് ഏരിയകളെക്കുറിച്ചും അറിയുകയാണെങ്കിൽ, ഒരു ഫംഗ്ഷൻ സുരക്ഷിതമാണോ അല്ലയോ എന്ന് റിവേഴ്സ് എഞ്ചിനിയറിംഗ് വഴി വിലയിരുത്താൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If you’ve never been exposed to the world of security and hacking, I hope that this chapter has served as a good introduction to the topic.","translation":"നിങ്ങൾ ഇതുവരെ സുരക്ഷയുടെയും ഹാക്കിംഗിന്റെയും ലോകം കണ്ടിട്ടില്ലെങ്കിൽ, ഈ അധ്യായം വിഷയത്തെക്കുറിച്ച് നല്ലൊരു ആമുഖമായിരിക്കുമെന്ന് ഞാൻ കരുതുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"There are thousands of articles online and dozens of books on these subjects.","translation":"ഈ വിഷയങ്ങളെക്കുറിച്ച് ആയിരക്കണക്കിന് ലേഖനങ്ങളും, നിരവധി പുസ്തകങ്ങളും ഓൺലൈനിൽ ലഭ്യമാണ്.","target_lang":"ml","domain":"general","complexity":"simple"}
{"en":"One good place to start is Phrack, the online magazine at www.phrack.org.","translation":"ആരംഭിക്കാൻ നല്ലൊരു സ്ഥലം www.phrack.org എന്ന വെബ്സൈറ്റിലുള്ള Phrack എന്ന ഓൺലൈൻ മാഗസിനാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Malicious software (or malware) is any program that works against the interests of the system’s user or owner.","translation":"മാലിഷ്യസ് സോഫ്റ്റ്‌വെയർ (അല്ലെങ്കിൽ മാൽവെയർ) എന്നത് സിസ്റ്റം ഉപയോക്താവിൻ്റെയോ ഉടമയുടെയോ താൽപ്പര്യങ്ങൾക്ക് വിരുദ്ധമായി പ്രവർത്തിക്കുന്ന ഏതൊരു പ്രോഗ്രാമുമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Generally speaking, computer users expect the computer and all of the software running on it to work on their behalf.","translation":"പൊതുവേ, കമ്പ്യൂട്ടർ ഉപയോക്താക്കൾ കമ്പ്യൂട്ടറും അതിൽ പ്രവർത്തിക്കുന്ന എല്ലാ സോഫ്റ്റ്‌വെയറുകളും തങ്ങൾക്കുവേണ്ടി പ്രവർത്തിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"}
{"en":"Any program that violates this rule is considered malware, because it works in the interest of other people.","translation":"ഈ നിയമം ലംഘിക്കുന്ന ഏതൊരു പ്രോഗ്രാമും മാൽവെയർ ആയി കണക്കാക്കപ്പെടുന്നു, കാരണം ഇത് മറ്റ് ആളുകളുടെ താൽപ്പര്യങ്ങൾക്കായി പ്രവർത്തിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Imagine what happens when a company CEO decides to spy on all company employees.","translation":"ഒരു കമ്പനി സിഇഒ, എല്ലാ ജീവനക്കാരെയും രഹസ്യമായി നിരീക്ഷിക്കാൻ തീരുമാനിച്ചാൽ എന്ത് സംഭവിക്കുമെന്ന് സങ്കൽപ്പിക്കുക.","target_lang":"ml","domain":"general","complexity":"moderate"}
{"en":"There are numerous programs available that report all kinds of usage statistics and Web-browsing habits.","translation":"വിവിധതരം ഉപയോഗ സ്ഥിതിവിവരക്കണക്കുകളും വെബ് ബ്രൗസിംഗ് ശീലങ്ങളും റിപ്പോർട്ട് ചെയ്യുന്ന നിരവധി പ്രോഗ്രാമുകൾ ലഭ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This chapter introduces the concept of malware and describes the purpose of these programs and how they work.","translation":"ഈ അധ്യായം മാൽവെയർ എന്ന ആശയം അവതരിപ്പിക്കുകയും ഈ പ്രോഗ്രാമുകളുടെ ഉദ്ദേശ്യത്തെയും അവ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെയും കുറിച്ച് വിവരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"We will be getting into the different types of malware currently in existence, and we’ll describe the various techniques they employ in hiding from end users and from antivirus programs.","translation":"നിലവിൽ നിലവിലുള്ള വിവിധതരം മാൽവെയറുകളെക്കുറിച്ചും, അന്തിമ ഉപയോക്താക്കളിൽ നിന്നും, ആന്റിവൈറസ് പ്രോഗ്രാമുകളിൽ നിന്നും എങ്ങനെയാണ് അവ സ്വയം മറയ്ക്കുന്നത് എന്നതിനെക്കുറിച്ചും നമ്മൾ ചർച്ച ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Viruses are self-replicating programs that usually have a malicious intent.","translation":"വൈറസുകൾ സാധാരണയായി ദോഷകരമായ ഉദ്ദേശങ്ങളുള്ള സ്വയം പകർപ്പെടുക്കുന്ന പ്രോഗ്രാമുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"They are the oldest breed of malware and have become slightly less popular these days, now that there is the Internet.","translation":"ഇവ ഏറ്റവും പഴയ മാൽവെയറുകളാണ്, ഇപ്പോൾ ഇന്റർനെറ്റ് വന്നതിനുശേഷം ഇവയുടെ പ്രചാരം കുറഞ്ഞിട്ടുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The unique thing about a virus that sets it apart from all other conventional programs is its self-replication.","translation":"മറ്റ് എല്ലാ പരമ്പരാഗത പ്രോഗ്രാമുകളിൽ നിന്നും ഒരു വൈറസിനെ വ്യത്യസ്തമാക്കുന്നത് അതിന്റെ സ്വയം പകർപ്പെടുക്കാനുള്ള കഴിവാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Worms can spread using several different techniques.","translation":"വിവിധ തരം ടെക്നിക്കുകൾ ഉപയോഗിച്ച് വിരകൾക്ക് വ്യാപിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"A worm is fundamentally similar to a virus in the sense that it is a self-replicating malicious program.","translation":"ഒരു വിര, ഒരു വൈറസിനു സമാനമാണ്, കാരണം ഇത് സ്വയം പകർപ്പെടുക്കുന്ന ഒരു ദോഷകരമായ പ്രോഗ്രാമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The general idea is that a Trojan horse is an innocent artifact openly delivered through the front door when it in fact contains a malicious element hidden somewhere inside of it.","translation":"ട്രോജൻ ഹോഴ്സ് എന്ന ആശയം, പുറമെ നിഷ്കളങ്കമെന്ന് തോന്നുമെങ്കിലും, അതിന്റെ ഉള്ളിൽ ഒരു ദോഷകരമായ ഘടകം ഒളിപ്പിച്ചുവച്ചിരിക്കുന്ന ഒന്നിനെക്കുറിച്ചാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In the software world, this translates to seemingly innocent files that actually contain some kind of malicious code underneath.","translation":"സോഫ്റ്റ്‌വെയർ ലോകത്ത്, ഇത് യഥാർത്ഥത്തിൽ ചിലതരം ദോഷകരമായ കോഡുകൾ അടങ്ങിയ, നിഷ്കളങ്കമെന്ന് തോന്നുന്ന ഫയലുകളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Hiding the program can be as simple as naming it in a way that would make end users think it is benign.","translation":"പ്രോഗ്രാം മറയ്ക്കുന്നത്, അത് ഉപയോക്താക്കൾക്ക് ദോഷകരമല്ലാത്ത ഒന്നാണെന്ന് തോന്നുന്ന രീതിയിൽ പേര് നൽകുന്നത്ര ലളിതമായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Once the existence of a malicious program is detected, malware researchers are going to start analyzing and dissecting it.","translation":"ഒരു ദോഷകരമായ പ്രോഗ്രാമിന്റെ സാന്നിധ്യം കണ്ടെത്തിയാൽ, മാൽവെയർ ഗവേഷകർ അത് വിശകലനം ചെയ്യാനും വിഭജിക്കാനും തുടങ്ങും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Most of this work revolves around conventional code reversing, but it also frequently relies on system tools such as network- and file-monitoring programs.","translation":"ഈ പ്രവർത്തനങ്ങളിൽ ഭൂരിഭാഗവും പരമ്പരാഗത കോഡ് റിവേഴ്സിംഗിനെ ആശ്രയിച്ചിരിക്കുന്നു, എന്നാൽ ഇത് സാധാരണയായി നെറ്റ്‌വർക്ക്, ഫയൽ മോണിറ്ററിംഗ് പ്രോഗ്രാമുകൾ പോലുള്ള സിസ്റ്റം ടൂളുകളെയും ആശ്രയിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Still, the most powerful analysis method remains code-level analysis, and malware authors sometimes attempt to hinder this process by use of antireversing techniques.","translation":"എങ്കിലും, ഏറ്റവും ശക്തമായ വിശകലന രീതി കോഡ്-ലെവൽ വിശകലനമായി തുടരുന്നു, കൂടാതെ മാൽവെയർ രചയിതാക്കൾ ചിലപ്പോൾ ആന്റിറിവേഴ്സിംഗ് ടെക്നിക്കുകൾ ഉപയോഗിച്ച് ഈ പ്രക്രിയ തടസ്സപ്പെടുത്താൻ ശ്രമിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"These are techniques that attempt to scramble and complicate the code in ways that prolong the analysis process.","translation":"വിശകലന പ്രക്രിയ നീട്ടിക്കൊണ്ടുപോകു രീതിയിൽ കോഡിനെ ആശയക്കുഴപ്പത്തിലാക്കാനും സങ്കീർണ്ണമാക്കാനും ശ്രമിക്കുന്ന സാങ്കേതിക വിദ്യകളാണിവ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is important to keep in mind that most of the techniques in this realm are quite limited and can only strive to complicate the process somewhat, but never to actually prevent it.","translation":"ഈ മേഖലയിലെ മിക്ക ടെക്നിക്കുകളും വളരെ പരിമിതമാണെന്നും, പ്രക്രിയയെ അൽപ്പം സങ്കീർണ്ണമാക്കാൻ മാത്രമേ ശ്രമിക്കൂ എന്നും ഓർമ്മിക്കേണ്ടത് പ്രധാനമാണ്, എന്നാൽ ഇത് ഒരിക്കലും തടയാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Polymorphism is a technique that thwarts signature-based identification programs by randomly encoding or encrypting the program code in a way that maintains its original functionality.","translation":"പോളിമോർഫിസം എന്നത്, പ്രോഗ്രാം കോഡിനെ ക്രമരഹിതമായി എൻകോഡ് ചെയ്യുന്നതിലൂടെയോ എൻക്രിപ്റ്റ് ചെയ്യുന്നതിലൂടെയോ ഒറിജിനൽ പ്രവർത്തനം നിലനിർത്തുന്ന ഒരു സാങ്കേതികതയാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The simplest approach to polymorphism is based on encrypting the program using a random key and decrypting it at runtime.","translation":"പോളിമോർഫിസത്തിനായുള്ള ഏറ്റവും ലളിതമായ സമീപനം, ഒരു random key ഉപയോഗിച്ച് പ്രോഗ്രാം എൻക്രിപ്റ്റ് ചെയ്യുകയും റൺടൈമിൽ അത് ഡീക്രിപ്റ്റ് ചെയ്യുകയും ചെയ്യുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Depending on when an antivirus program scans the program for its signature, this might prevent accurate identification of a malicious program because each copy of it is entirely different.","translation":"ആൻ്റിവൈറസ് പ്രോഗ്രാം ഒരു പ്രോഗ്രാമിൻ്റെ സിഗ്നേച്ചർ എപ്പോഴാണ് സ്കാൻ ചെയ്യുന്നത് എന്നതിനെ ആശ്രയിച്ചിരിക്കും ഇത്. കാരണം, ഇതിൻ്റെ ഓരോ കോപ്പിയും പൂർണ്ണമായും വ്യത്യസ്തമായതിനാൽ ദോഷകരമായ പ്രോഗ്രാമിനെ കൃത്യമായി തിരിച്ചറിയുന്നത് തടഞ്ഞേക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"There are two significant weaknesses with these kinds of solutions.","translation":"ഇത്തരം പരിഹാരങ്ങൾക്ക് രണ്ട് പ്രധാന പോരായ്മകളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"First of all, many antivirus programs might scan for virus signatures in memory.","translation":"ഒന്നാമതായി, പല ആന്റിവൈറസ് പ്രോഗ്രാമുകളും മെമ്മറിയിൽ വൈറസ് സിഗ്നേച്ചറുകൾക്കായി സ്കാൻ ചെയ്തേക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Because in most cases the program is going to be present in memory in its original, unencrypted form, the antivirus program won’t have a problem matching the running program with the signature it has on file.","translation":"മിക്ക കേസുകളിലും പ്രോഗ്രാം അതിന്റെ യഥാർത്ഥ, എൻക്രിപ്റ്റ് ചെയ്യാത്ത രൂപത്തിൽ മെമ്മറിയിൽ ഉണ്ടാകുന്നതിനാൽ, പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമിനെ ഫയലിലുള്ള സിഗ്നേച്ചറുമായി പൊരുത്തപ്പെടുത്തുന്നതിൽ ആന്റിവൈറസ് പ്രോഗ്രാമിന് പ്രശ്നമുണ്ടാകില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The second weakness lies in the decryption code itself.","translation":"രണ്ടാമത്തെ പോരായ്മ ഡീക്രിപ്ഷൻ കോഡിൽ തന്നെയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Even if an antivirus program only uses on-disk files in order to match malware signatures, there is still the problem of the decryption code being static.","translation":"മാൽവെയർ സിഗ്നേച്ചറുകൾ പൊരുത്തപ്പെടുത്തുന്നതിന് ഒരു ആന്റിവൈറസ് പ്രോഗ്രാം ഓൺ-ഡിസ്ക് ഫയലുകൾ മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ എങ്കിലും, ഡീക്രിപ്ഷൻ കോഡ് സ്ഥിരമായിരിക്കുന്ന പ്രശ്നമുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For the program to actually be able to run, it must decrypt itself in memory, and it is this decryption code that could theoretically be used as the signature.","translation":"പ്രോഗ്രാം പ്രവർത്തിക്കാൻ, അത് മെമ്മറിയിൽ സ്വയം ഡീക്രിപ്റ്റ് ചെയ്യണം, കൂടാതെ ഈ ഡീക്രിപ്ഷൻ കോഡ് സൈദ്ധാന്തികമായി സിഗ്നേച്ചറായി ഉപയോഗിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The solution to these problems generally revolves around rotating or scrambling certain elements in the decryption code (or in the entire program) in ways that alter its signature yet preserve its original functionality.","translation":"ഈ പ്രശ്നങ്ങളുടെ പരിഹാരം സാധാരണയായി ഡീക്രിപ്ഷൻ കോഡിലെ (അല്ലെങ്കിൽ മുഴുവൻ പ്രോഗ്രാമിലെയും) ചില ഘടകങ്ങൾ മാറ്റുന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു, ഇത് അതിന്റെ ഒറിജിനൽ പ്രവർത്തനം നിലനിർത്തുകയും അതേസമയം സിഗ്നേച്ചർ മാറ്റുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Consider the following sequence as an example:","translation":"ഒരു ഉദാഹരണമായി താഴെ പറയുന്ന ശ്രേണി പരിഗണിക്കുക:","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"One almost trivial method that would make it a bit more difficult to identify this sequence would consist of simply randomizing the use of registers in the code.","translation":"ഈ ശ്രേണി തിരിച്ചറിയുന്നത് അൽപ്പം ബുദ്ധിമുട്ടാക്കുന്ന ഒരു ലളിതമായ രീതി, കോഡിലെ രജിസ്റ്ററുകളുടെ ഉപയോഗം ക്രമരഹിതമാക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Metamorphism is the next logical step after polymorphism.","translation":"പോളിമോർഫിസത്തിനു ശേഷമുള്ള അടുത്ത യുക്തിപരമായ ഘട്ടമാണ് മെറ്റാമോർഫിസം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Instead of encrypting the program’s body and making slight alterations in the decryption engine, it is possible to alter the entire program each time it is replicated.","translation":"പ്രോഗ്രാമിന്റെ ഭാഗം എൻക്രിപ്റ്റ് ചെയ്യുകയും ഡീക്രിപ്ഷൻ എഞ്ചിനിൽ ചെറിയ മാറ്റങ്ങൾ വരുത്തുന്നതിനുപകരം, ഇത് ഓരോ തവണയും പകർപ്പെടുക്കുമ്പോൾ പ്രോഗ്രാം പൂർണ്ണമായും മാറ്റാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If the program has not yet been installed, it proceeds to copy itself to the SYSTEM32 directory under the name ZoneLockup.exe.","translation":"പ്രോഗ്രാം ഇതുവരെ ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ലെങ്കിൽ, അത് സ്വയം ZoneLockup.exe എന്ന പേരിൽ SYSTEM32 ഡയറക്ടറിയിലേക്ക് പകർത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The new instance of the process is obviously going to run this exact same code.","translation":"പ്രക്രിയയുടെ പുതിയ ഇൻസ്റ്റൻസ് തീർച്ചയായും ഇതേ കോഡ് പ്രവർത്തിപ്പിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This sequence checks whether this is the first time that the program is launched from its permanent habitat.","translation":"പ്രോഗ്രാം അതിന്റെ സ്ഥിരമായ സ്ഥലത്ത് നിന്ന് ആദ്യമായി പ്രവർത്തിപ്പിക്കുന്നത് ആണോ എന്ന് ഈ ശ്രേണി പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The program needs this information so that it can delete this file.","translation":"ഈ ഫയൽ ഇല്ലാതാക്കാൻ കഴിയുന്നതിന് പ്രോഗ്രാമിന് ഈ വിവരങ്ങൾ ആവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It wouldn’t have been possible to delete the executable while the program was still running.","translation":"പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ എക്സിക്യൂട്ടബിൾ ഫയൽ നീക്കം ചെയ്യാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The function proceeds to create a mutex called botsmfdutpex, whatever that means.","translation":"botsmfdutpex എന്ന് പേരുള്ള ഒരു മ്യൂട്ടക്സ് ഉണ്ടാക്കാൻ ഫംഗ്ഷൻ തുടരുന്നു, അതിനർത്ഥമെന്തായാലും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The purpose of this mutex is to make sure no other instances of the program are already running.","translation":"പ്രോഗ്രാമിന്റെ മറ്റ് ഇൻസ്റ്റൻസുകൾ ഇതിനകം പ്രവർത്തിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുക എന്നതാണ് ഈ മ്യൂട്ടക്സിന്റെ ലക്ഷ്യം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This mechanism ensures that the program doesn’t try to infect the same host twice.","translation":"ഒരേ ഹോസ്റ്റിനെ രണ്ടുതവണ ബാധിക്കാൻ പ്രോഗ്രാം ശ്രമിക്കില്ലെന്ന് ഈ സംവിധാനം ഉറപ്പാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It collects several bits of information regarding the host, including the exact version of the operating system, and the currently logged-on user.","translation":"ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ കൃത്യമായ പതിപ്പ്, നിലവിൽ ലോഗിൻ ചെയ്ത ഉപയോക്താവ് എന്നിവയുൾപ്പെടെ ഹോസ്റ്റിനെക്കുറിച്ചുള്ള നിരവധി വിവരങ്ങൾ ഇത് ശേഖരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The program is checking for a network connection and is simply waiting for the system to become connected if it’s not already connected.","translation":"പ്രോഗ്രാം ഒരു നെറ്റ്‌വർക്ക് കണക്ഷൻ പരിശോധിക്കുകയും, കണക്ട് ആയിട്ടില്ലെങ്കിൽ, സിസ്റ്റം കണക്ട് ആകുന്നതുവരെ കാത്തിരിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Once the connection check succeeds, the function calls another function, 004029B1.","translation":"കണക്ഷൻ പരിശോധന വിജയിച്ചാൽ, ഫംഗ്ഷൻ 004029B1 എന്ന മറ്റൊരു ഫംഗ്ഷൻ വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It looks like the Trojan is looking to chat with someone.","translation":"ട്രോജൻ ആരോടെങ്കിലും ചാറ്റ് ചെയ്യാൻ ശ്രമിക്കുന്നതായി തോന്നുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The specific address being referenced is g.hackarmy.tk, which was invalid at the time of writing.","translation":" g.hackarmy.tk എന്ന വിലാസമാണ് ഇവിടെ പരാമർശിക്കുന്നത്, ഇത് എഴുതുമ്പോൾ സാധുതയില്ലാത്തതായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"To really test the Trojan’s backdoor capabilities, I set up an IRC server on a separate virtual machine.","translation":"ട്രോജന്റെ ബാക്ക്ഡോർ കഴിവുകൾ ശരിക്കും പരീക്ഷിക്കാൻ, ഞാൻ ഒരു പ്രത്യേക വെർച്വൽ മെഷീനിൽ ഒരു IRC സെർവർ സ്ഥാപിച്ചു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This generates some kind of random data (with the random seed taken from the current tick counter).","translation":"ഇത് ഒരുതരം ക്രമരഹിതമായ ഡാറ്റ ഉണ്ടാക്കുന്നു (നിലവിലെ ടിക്ക് കൗണ്ടറിൽ നിന്ന് എടുത്ത ക്രമരഹിതമായ സീഡ് ഉപയോഗിച്ച്).","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Observing the resulting buffer in OllyDbg exposes that the program is essentially producing a short random string.","translation":"OllyDbg-യിലെ ഫലമായുണ്ടാകുന്ന ബഫർ നിരീക്ഷിക്കുമ്പോൾ, പ്രോഗ്രാം ഒരു ചെറിയ ക്രമരഹിതമായ സ്ട്രിംഗ് ഉണ്ടാക്കുന്നു എന്ന് വെളിപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is essentially a primitive antireversing scheme that’s supposed to make it a bit more difficult to find the password string.","translation":"പാസ്‌വേഡ് സ്ട്രിംഗ് കണ്ടെത്തുന്നത് അൽപ്പം ബുദ്ധിമുട്ടാക്കാൻ ഉദ്ദേശിച്ചുള്ള ഒരു പ്രാകൃത ആന്റിറിവേഴ്സിംഗ് സ്കീമാണിത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Now that we have the password, you can type it into our IRC program and try to establish a real communications channel with the backdoor.","translation":"ഇപ്പോൾ നമ്മുടെ പക്കൽ പാസ്‌വേഡ് ഉണ്ട്, നിങ്ങൾക്ക് ഇത് ഞങ്ങളുടെ IRC പ്രോഗ്രാമിൽ ടൈപ്പ് ചെയ്യാനും ബാക്ക്‌ഡോറുമായി ഒരു യഥാർത്ഥ ആശയവിനിമയ ചാനൽ സ്ഥാപിക്കാനും ശ്രമിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Disassembling this function to figure out the supported commands is an almost trivial task.","translation":"സപ്പോർട്ട് ചെയ്യുന്ന കമാൻഡുകൾ കണ്ടെത്താൻ ഈ ഫംഗ്ഷൻ വിഘടിപ്പിക്കുന്നത് ഏതാണ്ട് ലളിതമായ ഒരു ജോലിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"You start out by joining the ##g## channel and saying the password.","translation":"നിങ്ങൾ ##g## ചാനലിൽ പ്രവേശിച്ച് പാസ്‌വേഡ് പറയുന്നതിലൂടെ ആരംഭിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The program is launched in a hidden mode to keep the end user out of the loop.","translation":"അവസാന ഉപയോക്താവിനെ വിവരമറിയിക്കാതെ രഹസ്യമായി പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Developers of applications and operating systems must constantly improve the way these programs handle untrusted code.","translation":"ആപ്ലിക്കേഷനുകളുടെയും, ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെയും ഡെവലപ്പർമാർ, വിശ്വാസമില്ലാത്ത കോഡുകൾ കൈകാര്യം ചെയ്യുന്ന രീതി നിരന്തരം മെച്ചപ്പെടുത്തണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Educating end users on how these programs work and what to watch out for is critical.","translation":"ഈ പ്രോഗ്രാമുകൾ എങ്ങനെ പ്രവർത്തിക്കുമെന്നും, എന്തൊക്കെ ശ്രദ്ധിക്കണമെന്നും ഉപയോക്താക്കളെ പഠിപ്പിക്കുന്നത് വളരെ പ്രധാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In this chapter, you have learned a bit about malicious programs, how they work, and how they hide themselves.","translation":"ഈ അധ്യായത്തിൽ, ദോഷകരമായ പ്രോഗ്രാമുകളെക്കുറിച്ചും, അവ എങ്ങനെ പ്രവർത്തിക്കുന്നു, എങ്ങനെ സ്വയം മറയ്ക്കുന്നു എന്നതിനെക്കുറിച്ചും നിങ്ങൾ കുറച്ച് കാര്യങ്ങൾ പഠിച്ചു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Still, reversing malware can be seen as an excellent exercise in reverse engineering.","translation":"എങ്കിലും, മാൽവെയർ റിവേഴ്സ് ചെയ്യുന്നത്, റിവേഴ്സ് എഞ്ചിനിയറിംഗിന്റെ മികച്ച പരിശീലനമായി കണക്കാക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The magnitude of piracy committed on all kinds of digital content has become monstrous.","translation":"സംഗീതം, സോഫ്റ്റ്‌വെയർ, സിനിമകൾ തുടങ്ങിയ എല്ലാത്തരം ഡിജിറ്റൽ ഉള്ളടക്കത്തിലും നടക്കുന്ന പൈറസി ഭയാനകമായി മാറിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This problem has huge economic repercussions and has been causing a certain creative stagnation.","translation":"ഈ പ്രശ്നം വലിയ സാമ്പത്തിക പ്രത്യാഘാതങ്ങൾ ഉണ്ടാക്കുന്നു, അതുപോലെതന്നെ ഇത് ഒരുതരം സർഗ്ഗാത്മക സ്തംഭനാവസ്ഥയ്ക്ക് കാരണമാകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This subject is closely related to reversing because cracking is essentially one and the same as reversing.","translation":"ഈ വിഷയം റിവേഴ്സിംഗുമായി അടുത്ത ബന്ധപ്പെട്ടിരിക്കുന്നു, കാരണം ക്രാക്കിംഗ് അടിസ്ഥാനപരമായി റിവേഴ്സിംഗിന് തുല്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Nowadays, software, movies, books, and music recordings are all exposed to the same problem.","translation":"ഇക്കാലത്ത്, സോഫ്റ്റ്‌വെയർ, സിനിമകൾ, പുസ്തകങ്ങൾ, സംഗീത റെക്കോർഡിംഗുകൾ എന്നിവയെല്ലാം ഒരേ പ്രശ്നത്തിന് വിധേയമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"They have absolutely no control over what happens to their precious assets.","translation":"അവരുടെ വിലപ്പെട്ട ആസ്തികൾക്ക് എന്ത് സംഭവിക്കുമെന്നതിനെക്കുറിച്ച് അവർക്ക് ഒട്ടും നിയന്ത്രണമില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"I’ve met dozens of otherwise law-abiding citizens who weren’t even aware of the fact that burning a copy of a commercial music recording or a software product is illegal.","translation":"ഒരു വാണിജ്യ സംഗീത റെക്കോർഡിംഗോ സോഫ്റ്റ്‌വെയർ ഉൽപ്പന്നമോ പകർപ്പവകാശം ലംഘിച്ച് ഉപയോഗിക്കുന്നത് നിയമവിരുദ്ധമാണെന്ന് അറിയാത്ത നിരവധി നിയമം അനുസരിക്കുന്ന പൗരന്മാരെ ഞാൻ കണ്ടുമുട്ടിയിട്ടുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Technological approaches are unlikely to ever offer perfect solutions to these problems.","translation":"സാങ്കേതികപരമായ സമീപനങ്ങൾ ഈ പ്രശ്നങ്ങൾക്ക് തികഞ്ഞ പരിഹാരം നൽകാൻ സാധ്യതയില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Who’s problem would that be, the copyright owner’s, or everyone’s?","translation":"അത് പകർപ്പവകാശ ഉടമയുടെ പ്രശ്നമാണോ അതോ എല്ലാവരുടെയും പ്രശ്നമാണോ?","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"In a study on global software piracy it was estimated that over $30 billion worth of software was illegally installed worldwide during the year 2003.","translation":"2003-ൽ ലോകമെമ്പാടുമുള്ള കണക്കുകൾ പ്രകാരം 30 ബില്യൺ ഡോളറിലധികം വിലമതിക്കുന്ന സോഫ്റ്റ്‌വെയർ നിയമവിരുദ്ധമായി ഇൻസ്റ്റാൾ ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This means that 36 percent of the total software products installed during that period were obtained illegally.","translation":"അതായത്, ആ കാലയളവിൽ ഇൻസ്റ്റാൾ ചെയ്ത മൊത്തം സോഫ്റ്റ്‌വെയർ ഉൽപ്പന്നങ്ങളിൽ 36 ശതമാനവും നിയമവിരുദ്ധമായി നേടിയതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The Internet allows for simple and anonymous transfer of information in a way that makes piracy a living nightmare.","translation":"ഇന്റർനെറ്റ് വിവരങ്ങൾ ലളിതമായും, രഹസ്യമായും കൈമാറാൻ അനുവദിക്കുന്നു, ഇത് പൈറസിയെ ഒരു പേടിസ്വപ്നമാക്കി മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s define the problem: What is the objective of copy protection technologies and why is it so difficult to attain?","translation":"പ്രശ്നം നിർവചിക്കാം: പകർപ്പവകാശ സംരക്ഷണ സാങ്കേതികവിദ്യകളുടെ ലക്ഷ്യമെന്താണ്, അത് നേടാൻ ഇത്രയധികം ബുദ്ധിമുട്ടാനുള്ള കാരണം?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The basic objective of most copy protection technologies is to control the way the protected software product is used.","translation":"മിക്ക പകർപ്പവകാശ സംരക്ഷണ സാങ്കേതികവിദ്യകളുടെയും അടിസ്ഥാന ലക്ഷ്യം, സംരക്ഷിക്കപ്പെട്ട സോഫ്റ്റ്‌വെയർ ഉൽപ്പന്നം ഉപയോഗിക്കുന്ന രീതി നിയന്ത്രിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"A class break takes place when a security technology or product fails in a way that affects every user of that technology or product.","translation":"ഒരു സുരക്ഷാ സാങ്കേതികവിദ്യയോ ഉൽപ്പന്നമോ പരാജയപ്പെടുമ്പോൾ, ആ സാങ്കേതികവിദ്യയുടെയോ ഉൽപ്പന്നത്തിന്റെയോ എല്ലാ ഉപയോക്താക്കളെയും ബാധിക്കുന്ന രീതിയിൽ ക്ലാസ് ബ്രേക്ക് സംഭവിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Publishing such a crack not only means that the cracked program is now freely available online, but sometimes even that every program protected with the same protection technology can now be easily duplicated.","translation":"അത്തരത്തിലുള്ള ഒരു ക്രാക്ക് പ്രസിദ്ധീകരിക്കുന്നത്, ക്രാക്ക് ചെയ്ത പ്രോഗ്രാം ഇപ്പോൾ ഓൺലൈനിൽ സൗജന്യമായി ലഭ്യമാണ് എന്ന് മാത്രമല്ല, അതേ സംരക്ഷണ സാങ്കേതികവിദ്യ ഉപയോഗിച്ച് സംരക്ഷിച്ചിട്ടുള്ള എല്ലാ പ്രോഗ്രാമുകളും ഇപ്പോൾ എളുപ്പത്തിൽ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യാൻ കഴിയും എന്നും അർത്ഥമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The solution to this problem only became economically feasible in recent years, because it involves the inclusion of an actual encryption engine within the dongle.","translation":"ഈ പ്രശ്നത്തിനുള്ള പരിഹാരം സമീപ വർഷങ്ങളിൽ സാമ്പത്തികമായി സാധ്യമായത്, ഡോംഗിളിനുള്ളിൽ ഒരു യഥാർത്ഥ എൻക്രിപ്ഷൻ എഞ്ചിൻ ഉൾപ്പെടുത്തുന്നത് ഉൾപ്പെടുന്നതിനാലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This completely changes the rules of the game because it is no longer possible to rip the keys from the dongle and emulate the dongle.","translation":"ഇത് കളിയുടെ നിയമങ്ങൾ പൂർണ്ണമായും മാറ്റുന്നു, കാരണം ഡോംഗിളിൽ നിന്ന് കീകൾ എടുത്ത് ഡോംഗിൾ അനുകരിക്കാൻ ഇനി സാധ്യമല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"When the dongle actually has a microprocessor and is able to internally decrypt data, it becomes possible to hide the keys inside the dongle and there is never a need to expose the encryption keys to the untrusted CPU.","translation":"ഡോംഗിളിന് ഒരു മൈക്രോപ്രൊസസ്സർ ഉണ്ടായിരിക്കുകയും ഡാറ്റയെ ആന്തരികമായി ഡീക്രിപ്റ്റ് ചെയ്യാൻ കഴിയുകയും ചെയ്യുമ്പോൾ, കീകൾ ഡോംഗിളിനുള്ളിൽ മറയ്ക്കാൻ കഴിയും, കൂടാതെ എൻക്രിപ്ഷൻ കീകൾ വിശ്വാസമില്ലാത്ത CPU-യിലേക്ക് എക്സ്പോസ് ചെയ്യേണ്ടതില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Keeping the encryption keys safe inside the dongle makes it effectively impossible to emulate the don- gle.","translation":"എൻക്രിപ്ഷൻ കീകൾ ഡോംഗിളിനുള്ളിൽ സുരക്ഷിതമായി സൂക്ഷിക്കുന്നത് ഡോംഗിൾ അനുകരിക്കുന്നത് ഫലപ്രദമായി അസാധ്യമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"At that point the only approach a cracker can take is to rip the decrypted code from memory piece by piece.","translation":"ആ ഘട്ടത്തിൽ ഒരു ക്രാക്കർക്ക് എടുക്കാൻ കഴിയുന്ന ഒരേയൊരു സമീപനം, മെമ്മറിയിൽ നിന്ന് ഡീക്രിപ്റ്റ് ചെയ്ത കോഡ് ഓരോ കഷണങ്ങളായി എടുക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Remember that smart protection technologies never keep the entire program unencrypted in memory, so this might not be as easy as it sounds.","translation":"ഓർക്കുക, സ്മാർട്ട് പ്രൊട്ടക്ഷൻ ടെക്നോളജികൾ ഒരിക്കലും പ്രോഗ്രാം മുഴുവനും മെമ്മറിയിൽ എൻക്രിപ്റ്റ് ചെയ്യാതെ സൂക്ഷിക്കില്ല, അതിനാൽ ഇത് കേൾക്കുന്നത്ര എളുപ്പമായിരിക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Server-based software isn’t a suitable model for every type of software, but certain applications can really benefit from it.","translation":"സെർവർ അടിസ്ഥാനമാക്കിയുള്ള സോഫ്റ്റ്‌വെയർ എല്ലാത്തരം സോഫ്റ്റ്‌വെയറുകൾക്കും അനുയോജ്യമായ ഒരു മാതൃകയല്ല, എന്നാൽ ചില ആപ്ലിക്കേഷനുകൾക്ക് ഇത് ശരിക്കും പ്രയോജനകരമാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The reality is that software-based solutions can never be made uncrackable.","translation":"സോഫ്റ്റ്‌വെയർ അടിസ്ഥാനമാക്കിയുള്ള പരിഹാരങ്ങൾ ഒരിക്കലും തകർക്കാൻ കഴിയാത്തതാക്കാൻ കഴിയില്ല എന്നതാണ് യാഥാർത്ഥ്യം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Therefore, in order to achieve unbreakable (or at least nearly unbreakable) solutions there must be dedicated hardware that assists the protection technology.","translation":"അതുകൊണ്ട്, തകർക്കാനാവാത്ത (അല്ലെങ്കിൽ കുറഞ്ഞത് തകർക്കാൻ കഴിയാത്ത) പരിഹാരങ്ങൾ നേടുന്നതിന്, സംരക്ഷണ സാങ്കേതികവിദ്യയെ സഹായിക്കുന്ന പ്രത്യേക ഹാർഡ്‌വെയർ ഉണ്ടായിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The basic foundation for any good protection technology is encryption.","translation":"ഏത് നല്ല സംരക്ഷണ സാങ്കേതികവിദ്യയുടെയും അടിസ്ഥാനം എൻക്രിപ്ഷനാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"We must find a way to encrypt our protected content using a powerful cipher and safely decrypt it.","translation":"ഞങ്ങളുടെ സംരക്ഷിത ഉള്ളടക്കം ശക്തമായ ഒരു സൈഫർ ഉപയോഗിച്ച് എൻക്രിപ്റ്റ് ചെയ്യാനും സുരക്ഷിതമായി ഡീക്രിപ്റ്റ് ചെയ്യാനും ഒരു വഴി കണ്ടെത്തണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The problem is that computers are inherently open, which means that the plat- form is not designed to hide any data from the end user.","translation":"കമ്പ്യൂട്ടറുകൾ അന്തർലീനമായി തുറന്നതാണ് എന്നതാണ് പ്രശ്നം, അതായത് പ്ലാറ്റ്ഫോം അന്തിമ ഉപയോക്താവിൽ നിന്ന് ഒരു ഡാറ്റയും മറയ്ക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The solution to this problem (regardless of what it is that you’re trying to protect) is to include dedicated decryption hardware on the end user’s computer.","translation":"ഈ പ്രശ്നത്തിനുള്ള പരിഹാരം (നിങ്ങൾ എന്ത് സംരക്ഷിക്കാനാണ് ശ്രമിക്കുന്നതെങ്കിലും) അന്തിമ ഉപയോക്താവിൻ്റെ കമ്പ്യൂട്ടറിൽ സമർപ്പിത ഡീക്രിപ്ഷൻ ഹാർഡ്‌വെയർ ഉൾപ്പെടുത്തുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"A crypto-processor is a well-known software copy protection approach that was originally proposed by Robert M. Best in his patent Microprocessor for Exe- cuting Enciphered Programs[Best].","translation":"ഒരു ക്രിപ്റ്റോ-പ്രൊസസ്സർ എന്നത് സോഫ്റ്റ്‌വെയർ പകർപ്പ് സംരക്ഷണത്തിനായുള്ള ഒരു നല്ല രീതിയാണ്, ഇത് റോബർട്ട് എം. ബെസ്റ്റ് അദ്ദേഹത്തിൻ്റെ പേറ്റൻ്റായ എൻക്രിപ്റ്റ് ചെയ്ത പ്രോഗ്രാമുകൾ നടപ്പിലാക്കുന്നതിനുള്ള മൈക്രോപ്രൊസസ്സർ[Best]എന്നതിൽ ആദ്യമായി നിർദ്ദേശിച്ചത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The idea is simple: Design a microprocessor that can directly execute encrypted code by decrypting it on the fly.","translation":"ആശയം ലളിതമാണ്: എൻക്രിപ്റ്റ് ചെയ്ത കോഡ് തത്സമയം ഡീക്രിപ്റ്റ് ചെയ്തുകൊണ്ട് നേരിട്ട് എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുന്ന ഒരു മൈക്രോപ്രൊസസ്സർ രൂപകൽപ്പന ചെയ്യുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Each individual processor is assigned a pair of encryption keys and a serial number as part of the manufacturing process.","translation":"ഓരോ വ്യക്തിഗത പ്രൊസസ്സറിനും നിർമ്മാണ പ്രക്രിയയുടെ ഭാഗമായി ഒരു ജോഡി എൻക്രിപ്ഷൻ കീകൾ, ഒരു സീരിയൽ നമ്പർ എന്നിവ നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"When an end user purchases a program, the software developer requests the user’s processor serial number, and then contacts the authority to obtain the public key for that serial number.","translation":"ഒരു അന്തിമ ഉപയോക്താവ് ഒരു പ്രോഗ്രാം വാങ്ങുമ്പോൾ, സോഫ്റ്റ്‌വെയർ ഡെവലപ്പർ ഉപയോക്താവിൻ്റെ പ്രൊസസ്സർ സീരിയൽ നമ്പർ ആവശ്യപ്പെടുകയും തുടർന്ന് ആ സീരിയൽ നമ്പറിനായുള്ള പബ്ലിക് കീ ലഭിക്കുന്നതിന് അതോറിറ്റിയുമായി ബന്ധപ്പെടുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The program binaries are encrypted using the public key and shipped or transmitted to the end user.","translation":"പ്രോഗ്രാം ബൈനറികൾ പബ്ലിക് കീ ഉപയോഗിച്ച് എൻക്രിപ്റ്റ് ചെയ്യുകയും അന്തിമ ഉപയോക്താവിന് അയയ്ക്കുകയും അല്ലെങ്കിൽ കൈമാറുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The end user runs the encrypted program, and the crypto-processor decrypts the code using the internally stored decryption key (the user’s private key) and stores the decrypted code in a special memory region that is not software-accessible.","translation":"അന്തിമ ഉപയോക്താവ് എൻക്രിപ്റ്റ് ചെയ്ത പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു, കൂടാതെ ക്രിപ്റ്റോ-പ്രൊസസ്സർ ആന്തരികമായി സംഭരിച്ചിട്ടുള്ള ഡീക്രിപ്ഷൻ കീ (ഉപയോക്താവിൻ്റെ പ്രൈവറ്റ് കീ) ഉപയോഗിച്ച് കോഡ് ഡീക്രിപ്റ്റ് ചെയ്യുകയും സോഫ്റ്റ്‌വെയർ ആക്സസ് ചെയ്യാൻ കഴിയാത്ത ഒരു പ്രത്യേക മെമ്മറി ഭാഗത്ത് ഡീക്രിപ്റ്റ് ചെയ്ത കോഡ് സംഭരിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Code is executed directly from this (theoretically) inaccessible memory.","translation":"കോഡ് ഈ (സിദ്ധാന്തപരമായി) ലഭ്യമല്ലാത്ത മെമ്മറിയിൽ നിന്ന് നേരിട്ട് എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"In a regular non-bytecode-based compiled program, this simply means to strip all symbolic information from the program executable.","translation":"ഒരു സാധാരണ, ബൈറ്റ്കോഡ് അടിസ്ഥാനമാക്കാത്ത കംപൈൽ ചെയ്ത പ്രോഗ്രാമിൽ, പ്രോഗ്രാം എക്സിക്യൂട്ടബിളിൽ നിന്നുള്ള എല്ലാ ചിഹ്ന വിവരങ്ങളും നീക്കം ചെയ്യുക എന്നാണ് ഇതിനർത്ഥം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This information can be extremely helpful to reversers, which is why it absolutely must be eliminated from programs where reversing is a concern.","translation":"ഈ വിവരങ്ങൾ റിവേഴ്സറുകൾക്ക് വളരെ സഹായകമാകും, അതുകൊണ്ടാണ് റിവേഴ്സിംഗ് ഒരു പ്രശ്നമായിട്ടുള്ള പ്രോഗ്രാമുകളിൽ നിന്ന് ഇത് പൂർണ്ണമായും ഒഴിവാക്കേണ്ടത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The most fundamental feature of pretty much every bytecode obfuscator is to rename all symbols into meaningless sequences of characters.","translation":"ഏകദേശം എല്ലാ ബൈറ്റ്കോഡ് ഒബ്‌ഫസ്‌കേറ്ററുകളുടെയും ഏറ്റവും അടിസ്ഥാനപരമായ സവിശേഷത, എല്ലാ ചിഹ്നങ്ങളെയും അർത്ഥമില്ലാത്ത പ്രതീക ശ്രേണികളായി പുനർനാമകരണം ചെയ്യുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Obfuscating the ProgramObfuscation is a generic name for a number of techniques that are aimed at reducing the program’s vulnerability to any kind of static analysis.","translation":"പ്രോഗ്രാം ഒബ്‌ഫസ്‌കേഷൻ എന്നത് പ്രോഗ്രാമിന്റെ സ്ഥിരമായ വിശകലനത്തിനുള്ള സാധ്യത കുറയ്ക്കുന്നതിന് ലക്ഷ്യമിട്ടുള്ള നിരവധി സാങ്കേതിക വിദ്യകൾക്ക് നൽകിയിട്ടുള്ള ഒരു പൊതുവായ പേരാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is accomplished by modifying the program’s layout, logic, data, and organization in a way that keeps it functionally identical yet far less readable.","translation":"പ്രവർത്തനപരമായി സമാനമായി നിലനിർത്തുന്ന രീതിയിൽ പ്രോഗ്രാമിന്റെ ലേഔട്ട്, ലോജിക്, ഡാറ്റ, ഓർഗനൈസേഷൻ എന്നിവ പരിഷ്കരിക്കുന്നതിലൂടെ ഇത് സാധ്യമാക്കുന്നു, എന്നാൽ ഇത് വളരെ കുറഞ്ഞ വായനാക്ഷമതയുള്ളതാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Embedding Antidebugger CodeAnother common antireversing approach is aimed specifically at hindering live analysis.","translation":"ആൻ്റിഡീബഗ്ഗർ കോഡ് ഉൾപ്പെടുത്തുന്നത് തത്സമയ വിശകലനം തടസ്സപ്പെടുത്തുന്നതിനായി ലക്ഷ്യമിട്ടുള്ള മറ്റൊരു സാധാരണ രീതിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The idea is to have the program intentionally perform operations that would somehow damage or disable a debugger, if one is attached.","translation":"ഒരു ഡീബഗ്ഗർ അറ്റാച്ച് ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, അത് ഏതെങ്കിലും വിധത്തിൽ തകരാറിലാക്കുകയോ പ്രവർത്തനരഹിതമാക്കുകയോ ചെയ്യുന്ന പ്രവർത്തനങ്ങൾ മനഃപൂർവ്വം ചെയ്യുന്നതിനാണ് ഈ ആശയം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Some of these approaches involve simply detecting that a debugger is present and terminating the program if it is, while others involve more sophisticated means of interfering with debuggers in case one is present.","translation":"ഈ സമീപനങ്ങളിൽ ചിലത് ഒരു ഡീബഗ്ഗർ ഉണ്ടെന്ന് കണ്ടെത്തുന്നതും, അതുണ്ടെങ്കിൽ പ്രോഗ്രാം അവസാനിപ്പിക്കുന്നതും ഉൾപ്പെടുന്നു, മറ്റുള്ളവയിൽ ഒരെണ്ണം ഉണ്ടായാൽ ഡീബഗ്ഗറുകളിൽ ഇടപെടുന്നതിനുള്ള കൂടുതൽ സങ്കീർണ്ണമായ മാർഗ്ഗങ്ങൾ ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"There are numerous antidebugger approaches, and many of them are platform-specific or even debugger-specific.","translation":"നിരവധി ആൻ്റിഡീബഗ്ഗർ സമീപനങ്ങളുണ്ട്, അവയിൽ പലതും പ്ലാറ്റ്‌ഫോം-നിർദ്ദിഷ്ടമോ അല്ലെങ്കിൽ ഡീബഗ്ഗർ-നിർദ്ദിഷ്ടമോ ആണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Eliminating Symbolic Information There’s not really a whole lot to the process of information elimination.","translation":"ചിഹ്ന വിവരങ്ങൾ ഇല്ലാതാക്കുക വിവരങ്ങൾ ഇല്ലാതാക്കുന്ന പ്രക്രിയയിൽ ശരിക്കും അധികമൊന്നും ചെയ്യാനില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"If you’re a developer and you’re concerned about reversers, I’d recommend that you test your program for the presence of any useful symbolic information before it goes out the door.","translation":"നിങ്ങൾ ഒരു ഡെവലപ്പർ ആണെങ്കിൽ, റിവേഴ്സുകളെക്കുറിച്ച് നിങ്ങൾക്ക് ആശങ്കയുണ്ടെങ്കിൽ, പ്രോഗ്രാം പുറത്തിറക്കുന്നതിന് മുമ്പ്, ഉപയോഗപ്രദമായ ഏതെങ്കിലും ചിഹ്ന വിവരങ്ങൾ ഉണ്ടോയെന്ന് പരിശോധിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"One area where even compiler-based programs can contain a little bit of symbolic information is the import and export tables.","translation":"കംപൈലർ അടിസ്ഥാനമാക്കിയുള്ള പ്രോഗ്രാമുകളിൽ പോലും അൽപ്പം ചിഹ്ന വിവരങ്ങൾ അടങ്ങിയിരിക്കാൻ സാധ്യതയുള്ള ഒരു മേഖലയാണ് ഇംപോർട്ട്, എക്സ്പോർട്ട് ടേബിളുകൾ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Again, if you are a developer and are seriously concerned about people reversing your program, it might be worthwhile to export all functions by ordinals rather than by names.","translation":"നിങ്ങൾ ഒരു ഡെവലപ്പർ ആണെങ്കിൽ, നിങ്ങളുടെ പ്രോഗ്രാം റിവേഴ്സ് ചെയ്യുന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് ഗൗരവമായ ആശങ്കയുണ്ടെങ്കിൽ, പേരുകൾക്ക് പകരം ഓർഡിനൽസ് ഉപയോഗിച്ച് എല്ലാ ഫംഗ്ഷനുകളും എക്സ്പോർട്ട് ചെയ്യുന്നത് നന്നായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The issue of symbolic information is different with most bytecode-based languages.","translation":"ചിഹ്ന വിവരങ്ങളുടെ പ്രശ്നം മിക്ക ബൈറ്റ്കോഡ് അടിസ്ഥാനമാക്കിയുള്ള ഭാഷകളിലും വ്യത്യസ്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"That’s because these languages often use names for internal cross-referencing instead of addresses, so all internal names are preserved when a program is compiled.","translation":"കാരണം, ഈ ഭാഷകൾ പലപ്പോഴും വിലാസങ്ങൾക്ക് പകരം ആന്തരിക ക്രോസ്-റഫറൻസിംഗിനായി പേരുകൾ ഉപയോഗിക്കുന്നു, അതിനാൽ ഒരു പ്രോഗ്രാം കംപൈൽ ചെയ്യുമ്പോൾ എല്ലാ ആന്തരിക നാമങ്ങളും നിലനിർത്തപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This creates a situation in which many bytecode pro- grams can be decompiled back into an extremely readable source-code-like form.","translation":"ഇത് പല ബൈറ്റ്കോഡ് പ്രോഗ്രാമുകളും വളരെ വ്യക്തമായി വായിക്കാൻ കഴിയുന്ന സോഴ്സ്-കോഡ് പോലുള്ള രൂപത്തിലേക്ക് ഡീകംപൈൽ ചെയ്യാൻ കഴിയുന്ന ഒരു സാഹചര്യം സൃഷ്ടിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Code Encryption Encryption of program code is a common method for preventing static analy- sis.","translation":"കോഡ് എൻക്രിപ്ഷൻ പ്രോഗ്രാം കോഡിന്റെ എൻക്രിപ്ഷൻ സ്ഥിരമായ വിശകലനം തടയുന്നതിനുള്ള ഒരു സാധാരണ രീതിയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It is accomplished by encrypting the program at some point after it is com- piled (before it is shipped to the customer) and embedding some sort of decryption code inside the executable.","translation":"പ്രോഗ്രാം കംപൈൽ ചെയ്തതിന് ശേഷം (ഉപഭോക്താവിന് അയക്കുന്നതിന് മുമ്പ്) എൻക്രിപ്റ്റ് ചെയ്യുന്നതിലൂടെയും, എക്സിക്യൂട്ടബിളിനുള്ളിൽ ചിലതരം ഡീക്രിപ്ഷൻ കോഡ് ഉൾച്ചേർക്കുന്നതിലൂടെയും ഇത് സാധ്യമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Unfortunately, this approach usually creates nothing but inconvenience for the skillful reverser because in most cases everything required for the decryption of the program must reside inside the executable.","translation":" bedഭാഗ്യവശാൽ, ഈ സമീപനം സാധാരണയായി വൈദഗ്ധ്യമുള്ള റിവേഴ്സറിന് അസൗകര്യമുണ്ടാക്കുന്നു, കാരണം മിക്ക കേസുകളിലും പ്രോഗ്രാം ഡീക്രിപ്റ്റ് ചെയ്യാൻ ആവശ്യമായതെല്ലാം എക്സിക്യൂട്ടബിളിനുള്ളിൽ ഉണ്ടായിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The only way to fight the automatic unpacking of executables (other than to use separate hardware that stores the decryption key or actually performs the decryption) is to try and hide the key within the program.","translation":"എക്സിക്യൂട്ടബിളുകളുടെ ഓട്ടോമാറ്റിക് അൺപാക്കിംഗിനെ ചെറുക്കാനുള്ള ഒരേയൊരു വഴി (ഡീക്രിപ്ഷൻ കീ സംഭരിക്കുന്ന അല്ലെങ്കിൽ യഥാർത്ഥത്തിൽ ഡീക്രിപ്ഷൻ നടത്തുന്ന പ്രത്യേക ഹാർഡ്‌വെയർ ഉപയോഗിക്കുന്നതൊഴികെ) പ്രോഗ്രാമിനുള്ളിൽ കീ മറയ്ക്കാൻ ശ്രമിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Reversing a table interpretation function without a full view is an unpleasant task.","translation":"ഒരു പൂർണ്ണമായ കാഴ്ചയില്ലാതെ ഒരു പട്ടിക വ്യാഖ്യാന ഫംഗ്ഷൻ റിവേഴ്സ് ചെയ്യുന്നത് അസുഖകരമായ ഒരു ജോലിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Adding an additional lookup table is a powerful enhancement for obfuscation.","translation":"കൂടുതൽ ലുക്ക്അപ്പ് ടേബിൾ ചേർക്കുന്നത് അവ്യക്തതയ്ക്കുള്ള ശക്തമായ ഒരു മെച്ചപ്പെടുത്തലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The data-processing function was transformed using an array-based table interpretation method.","translation":"ഡാറ്റാ പ്രോസസ്സിംഗ് ഫംഗ്ഷൻ ഒരു അറേ അടിസ്ഥാനമാക്കിയുള്ള ടേബിൾ വ്യാഖ്യാന രീതി ഉപയോഗിച്ച് രൂപാന്തരപ്പെടുത്തി.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This function is an enhanced version of the function from Listing 10.3.","translation":"ഈ ഫംഗ്ഷൻ ലിസ്റ്റിംഗ് 10.3-ൽ നിന്നുള്ള ഫംഗ്ഷന്റെ മെച്ചപ്പെടുത്തിയ പതിപ്പാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This implementation uses an additional table filled in at runtime.","translation":"ഈ നടപ്പാത, റൺടൈമിൽ നിറച്ച ഒരു അധിക പട്ടിക ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This enhancement makes the function significantly more unreadable.","translation":"ഈ മെച്ചപ്പെടുത്തൽ ഫംഗ്ഷനെ വളരെയധികം വായിക്കാൻ കഴിയാത്തതാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Pointer aliases complicate data-flow analysis.","translation":"പോയിന്റർ അലിയാസുകൾ ഡാറ്റാ-ഒഴുക്ക് വിശകലനം സങ്കീർണ്ണമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It would be impossible for a deobfuscator to predict the array's state.","translation":"ഒരു ഡീഒബ്‌ഫസ്‌കേറ്ററിന് അറേയുടെ അവസ്ഥ പ്രവചിപ്പിക്കാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The obfuscated function was about 3.8 times slower.","translation":"അവ്യക്തമാക്കിയ ഫംഗ്ഷൻ ഏകദേശം 3.8 മടങ്ങ് വേഗത കുറവായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Extreme obfuscation depends on your concern about program reversal.","translation":"പ്രോഗ്രാം റിവേഴ്സലിനെക്കുറിച്ചുള്ള നിങ്ങളുടെ ആശങ്കകളെ ആശ്രയിച്ചിരിക്കുന്നു എക്സ്ട്രീം ഒബ്‌ഫസ്‌കേഷൻ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"There's usually no reason to obfuscate the entire program.","translation":"സാധാരണയായി, മുഴുവൻ പ്രോഗ്രാമും അവ്യക്തമാക്കേണ്ട കാര്യമില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Inlining eliminates internal abstractions.","translation":"ഇൻലൈനിംഗ് ആന്തരിക അമൂർത്തീകരണങ്ങൾ ഇല്ലാതാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Outlining creates a new function for a code sequence.","translation":"ഔട്ട്ലൈനിംഗ് ഒരു കോഡ് സീക്വൻസിനായി ഒരു പുതിയ ഫംഗ്ഷൻ ഉണ്ടാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Code interleaving is a potent obfuscation technique.","translation":"കോഡ് ഇന്റർലീവിംഗ് ശക്തമായ ഒരു അവ്യക്തീകരണ സാങ്കേതികതയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Each function segment is followed by an opaque predicate.","translation":"ഓരോ ഫംഗ്ഷൻ സെഗ്‌മെന്റിനുശേഷവും ഒരു непрозрачный പ്രെഡിക്കേറ്റ് ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Shuffling the order of operations confuses reversers.","translation":"പ്രവർത്തനങ്ങളുടെ ക്രമം മാറ്റുന്നത് റിവേഴ്സറുകളെ ആശയക്കുഴപ്പത്തിലാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Data transformations focus on obfuscating the program's data.","translation":"ഡാറ്റാ ട്രാൻസ്ഫോർമേഷനുകൾ പ്രോഗ്രാമിന്റെ ഡാറ്റയെ അവ്യക്തമാക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Modifying variable encoding can confuse reversers.","translation":"വേരിയബിൾ എൻകോഡിംഗ് പരിഷ്കരിക്കുന്നത് റിവേഴ്സറുകളെ ആശയക്കുഴപ്പത്തിലാക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Restructuring arrays can increase confusion.","translation":"അറേകൾ പുനഃക്രമീകരിക്കുന്നത് ആശയക്കുഴപ്പം വർദ്ധിപ്പിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Antireversing techniques have a cost in runtime performance.","translation":"ആന്റിറിവേഴ്സിംഗ് ടെക്നിക്കുകൾക്ക് റൺടൈം പ്രകടനത്തിൽ ചിലവ് ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The following listing was produced by IDA Pro.","translation":"താഴെയുള്ള ലിസ്റ്റിംഗ് IDA Pro ഉപയോഗിച്ച് ഉണ്ടാക്കിയതാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"As you can see, IDA bought into it and produced incorrect code.","translation":"നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, IDA ഇത് വിശ്വസിച്ച് തെറ്റായ കോഡ് ഉണ്ടാക്കി.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Does this mean that IDA Pro, which has a reputation for being one of the most powerful disassemblers around, is flawed in some way?","translation":"ഏറ്റവും ശക്തമായ ഡിസ്അസംബ്ലറുകളിൽ ഒന്നായി അറിയപ്പെടുന്ന IDA Pro, ഏതെങ്കിലും തരത്തിൽ തകരാറുള്ളതാണെന്ന് ഇതിനർത്ഥമുണ്ടോ?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Absolutely not.","translation":"ഒരിക്കലുമല്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"When you think about it, properly disassembling these kinds of code sequences is not a problem that can be solved in a generic method.","translation":"ഒന്ന് ആലോചിച്ചുനോക്കൂ, ഇത്തരം കോഡ് സീക്വൻസുകൾ ശരിയായി ഡിസ്അസംബിൾ ചെയ്യുന്നത് ഒരു പൊതുവായ രീതിയിൽ പരിഹരിക്കാൻ കഴിയുന്ന ഒരു പ്രശ്നമല്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The disassembler must contain specific heuristics that deal with these kinds of situations.","translation":"ഇത്തരം സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്ന പ്രത്യേക ഹ്യൂറിസ്റ്റിക്സുകൾ ഡിസ്അസംബ്ലറിൽ ഉണ്ടായിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Instead disassemblers such as IDA (and also OllyDbg) contain specific commands that inform the disassembler whether a certain byte is code or data.","translation":"IDA (കൂടാതെ OllyDbg) പോലുള്ള ഡിസ്അസംബ്ലറുകളിൽ ഒരു പ്രത്യേക ബൈറ്റ് കോഡാണോ ഡാറ്റയാണോ എന്ന് ഡിസ്അസംബ്ലറെ അറിയിക്കുന്ന കമാൻഡുകൾ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"To properly disassemble such code in these products, one would have to inform the disassembler that our junk byte is really data and not code.","translation":"ഈ ഉൽപ്പന്നങ്ങളിൽ അത്തരം കോഡ് ശരിയായി ഡിസ്അസംബിൾ ചെയ്യുന്നതിന്, ഞങ്ങളുടെ ജങ്ക് ബൈറ്റ് ശരിക്കും ഡാറ്റയാണെന്നും കോഡ് അല്ലെന്നും ഡിസ്അസംബ്ലറെ അറിയിക്കേണ്ടിവരും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This would solve the problem and the disassembler would produce a correct disassembly.","translation":"ഇത് പ്രശ്നം പരിഹരിക്കുകയും ഡിസ്അസംബ്ലർ ശരിയായ ഡിസ്അസംബ്ലി ഉണ്ടാക്കുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s go back to our sample from earlier and see how OllyDbg reacts to it.","translation":"നമുക്ക് നേരത്തെയുള്ള സാമ്പിളിലേക്ക് തിരിച്ചുപോയി OllyDbg എങ്ങനെയാണ് ഇതിനോട് പ്രതികരിക്കുന്നതെന്ന് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Olly is clearly ignoring the junk byte and using the conditional jump as a marker to the real code starting position, which is why it is providing an accurate listing.","translation":"Olly ജങ്ക് ബൈറ്റ് അവഗണിക്കുകയും യഥാർത്ഥ കോഡ് ആരംഭ സ്ഥാനത്തിനായുള്ള ഒരു മാർക്കറായി കണ്ടീഷണൽ ജമ്പ് ഉപയോഗിക്കുകയും ചെയ്യുന്നു, അതുകൊണ്ടാണ് ഇത് കൃത്യമായ ലിസ്റ്റിംഗ് നൽകുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It is possible that Olly contains specific code for dealing with these kinds of tricks.","translation":"ഇത്തരം തന്ത്രങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനായി Olly-യിൽ പ്രത്യേക കോഡ് ഉണ്ടാകാൻ സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Regardless, at this point it becomes clear that you can take advantage of Olly’s use of the jump’s target address to confuse it.","translation":"എന്തായാലും, ഈ ഘട്ടത്തിൽ, ആശയക്കുഴപ്പത്തിലാക്കാൻ ജമ്പിന്റെ ടാർഗെറ്റ് വിലാസം Olly ഉപയോഗിക്കുന്നത് നിങ്ങൾക്ക് പ്രയോജനപ്പെടുത്താമെന്ന് വ്യക്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If OllyDbg uses conditional jumps to mark the beginning of valid code sequences, you can just create a conditional jump that points to the beginning of the invalid sequence.","translation":"OllyDbg സാധുവായ കോഡ് സീക്വൻസുകളുടെ ആരംഭം അടയാളപ്പെടുത്താൻ കണ്ടീഷണൽ ജമ്പുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, അസാധുവായ സീക്വൻസിന്റെ തുടക്കത്തിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്ന ഒരു കണ്ടീഷണൽ ജമ്പ് നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The following code snippet demonstrates this idea:","translation":"ഇനി പറയുന്ന കോഡ് ഭാഗം ഈ ആശയം വ്യക്തമാക്കുന്നു:","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This sequence is an improved implementation of the same approach.","translation":"ഈ ശ്രേണി, അതേ സമീപനത്തിന്റെ മെച്ചപ്പെട്ട നടപ്പാക്കലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is more likely to confuse recursive traversal disassemblers because they will have to randomly choose which of the two jumps to use as indicators of valid code.","translation":"ഏത് രണ്ട് ജമ്പുകളാണ് സാധുവായ കോഡിന്റെ സൂചകങ്ങളായി ഉപയോഗിക്കേണ്ടതെന്ന് അവർക്ക് ക്രമരഹിതമായി തിരഞ്ഞെടുക്കേണ്ടിവരുമെന്നതിനാൽ ഇത് റിcursർസീവ് ട്രാവേഴ്സൽ ഡിസ്അസംബ്ലറുകളെ ആശയക്കുഴപ്പത്തിലാക്കാൻ സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The reason why this is not trivial is that both codes are “valid” from the disassembler’s perspective.","translation":"ഇത് ലളിതമല്ലാത്തതിന്റെ കാരണം, ഡിസ്അസംബ്ലറുടെ കാഴ്ചപ്പാടിൽ രണ്ട് കോഡുകളും ","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is a theoretical problem: the disassembler has no idea what constitutes valid code.","translation":"ഇതൊരു സൈദ്ധാന്തിക പ്രശ്നമാണ്: സാധുവായ കോഡ് എന്താണെന്ന് ഡിസ്അസംബ്ലർക്ക് അറിയില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s look at the listing Olly produces from the above code.","translation":"മുകളിലുള്ള കോഡിൽ നിന്ന് Olly ഉണ്ടാക്കുന്ന ലിസ്റ്റിംഗ് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The program uses GetDlgItemTextA to retrieve the text from the edit boxes.","translation":"പ്രോഗ്രാം എഡിറ്റ് ബോക്സുകളിൽ നിന്ന് ടെക്സ്റ്റ് വീണ്ടെടുക്കാൻ GetDlgItemTextA ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Keygenning is the process of creating programs that mimic the key-generation algorithm.","translation":"കീ-ജനറേഷൻ അൽഗോരിതം അനുകരിക്കുന്ന പ്രോഗ്രാമുകൾ നിർമ്മിക്കുന്ന പ്രക്രിയയാണ് കീജെനിംഗ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Software pirates use keygen programs to overcome the protection.","translation":"പ്രൊട്ടക്ഷൻ മറികടക്കാൻ സോഫ്റ്റ്‌വെയർ കള്ളന്മാർ കീജൻ പ്രോഗ്രാമുകൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The volume serial number is a 32-bit random number assigned to a partition.","translation":"വോളിയം സീരിയൽ നമ്പർ ഒരു പാർട്ടീഷന് നൽകിയിട്ടുള്ള 32-ബിറ്റ് റാൻഡം നമ്പറാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"KeygenMe-3 was meant to be keygenned, so by patching it you were essentially cheating.","translation":"KeygenMe-3 കീജെൻ ചെയ്യാൻ ഉദ്ദേശിച്ചുള്ളതായിരുന്നു, അതിനാൽ ഇത് പാച്ച് ചെയ്യുന്നതിലൂടെ നിങ്ങൾ അടിസ്ഥാനപരമായി ചതിക്കുകയായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Ripping algorithms from copy protection products is often an easy and effective method.","translation":"കോപ്പി പ്രൊട്ടക്ഷൻ ഉൽപ്പന്നങ്ങളിൽ നിന്ന് അൽഗോരിതങ്ങൾ വലിച്ചെടുക്കുന്നത് പലപ്പോഴും എളുപ്പമുള്ളതും ഫലപ്രദവുമായ ഒരു രീതിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Locate the function or functions within the protected program that calculate a valid serial number.","translation":"സാധുവായ സീരിയൽ നമ്പർ കണക്കാക്കുന്ന, പരിരക്ഷിത പ്രോഗ്രാമിനുള്ളിലെ ഫംഗ്ഷനോ ഫംഗ്ഷനുകളോ കണ്ടെത്തുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The initial task you must perform is to locate the key-generation algorithm within the crackme.","translation":"നിങ്ങൾ ചെയ്യേണ്ട പ്രാരംഭ ദൗത്യം ക്രാക്ക്മെക്കുള്ളിലെ കീ-ജനറേഷൻ അൽഗോരിതം കണ്ടെത്തുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is likely that the program would use GetDlgItemText or send the edit box a WM_GETTEXT message.","translation":"പ്രോഗ്രാം GetDlgItemText ഉപയോഗിക്കാനോ അല്ലെങ്കിൽ എഡിറ്റ് ബോക്സിലേക്ക് WM_GETTEXT സന്ദേശം അയയ്ക്കാനോ സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Working under the assumption that it’s GetDlgItemText you’re after, you can look for references.","translation":"GetDlgItemText ആണ് നിങ്ങൾക്കാവശ്യമെന്ന് അനുമാനിച്ചുകൊണ്ട്, നിങ്ങൾക്ക് റഫറൻസുകൾക്കായി തിരയാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The code starts out with ECX containing the length of the first input string.","translation":"ആദ്യത്തെ ഇൻപുട്ട് സ്ട്രിംഗിന്റെ നീളം ഉൾക്കൊള്ളുന്ന ECX ഉപയോഗിച്ചാണ് കോഡ് ആരംഭിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In the initial iteration EAX equals 1, so the actual address that is accessed is 403520.","translation":"ആരംഭ ഘട്ടത്തിൽ EAX 1 ന് തുല്യമാണ്, അതിനാൽ ആക്സസ് ചെയ്യുന്ന വിലാസം 403520 ആണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It converts the string that was passed in the parameter to a binary DWORD.","translation":"അത്, പരാമീറ്ററിൽ നൽകിയിട്ടുള്ള സ്ട്രിംഗിനെ ഒരു ബൈനറി DWORD ആക്കി മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The lower text box should contain the number produced by the first algorithm.","translation":"താഴെയുള്ള ടെക്സ്റ്റ് ബോക്സിൽ ആദ്യത്തെ അൽഗോരിതം ഉണ്ടാക്കിയ സംഖ്യ ഉണ്ടായിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s try that out.","translation":"അതൊന്ന് പരീക്ഷിച്ചുനോക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Defender takes a username and a 16-digit hexadecimal serial number.","translation":"Defender ഒരു ഉപയോക്തൃനാമവും 16-അക്ക ഹെക്സാഡെസിമൽ സീരിയൽ നമ്പറും സ്വീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Defender simply reports that we have a bad serial number.","translation":"Defender, തെറ്റായ സീരിയൽ നമ്പറാണ് നമ്മൾ നൽകിയത് എന്ന് റിപ്പോർട്ട് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Let’s load Defender.EXE into OllyDbg and take a first look at it.","translation":"Defender.EXE OllyDbg-യിൽ ലോഡ് ചെയ്ത് നമുക്ക് ആദ്യമായി അതൊന്ന് പരിശോധിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The program must be able to somehow communicate with the operating system.","translation":"പ്രോഗ്രാം ഏതെങ്കിലും വിധത്തിൽ ഓപ്പറേറ്റിംഗ് സിസ്റ്റവുമായി ആശയവിനിമയം നടത്താൻ കഴിയണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is a good idea to run the program in PEiD to see if it is packed.","translation":"പ്രോഗ്രാം പാക്ക് ചെയ്തിട്ടുണ്ടോയെന്ന് അറിയാൻ PEiD-യിൽ പ്രവർത്തിപ്പിക്കുന്നത് നല്ലതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The code snippet reveals the entry point function.","translation":"കോഡ് ഭാഗം എൻട്രി പോയിന്റ് ഫംഗ്ഷൻ വെളിപ്പെടുത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"A quick scan of the function reveals an important property.","translation":"ഫംഗ്ഷൻ പെട്ടെന്ന് പരിശോധിക്കുമ്പോൾ ഒരു പ്രധാന സ്വഭാവം വെളിപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The entry point is not a common runtime library initialization routine.","translation":"പ്രവേശന പോയിന്റ് സാധാരണ റൺടൈം ലൈബ്രറി പ്രാരംഭ ശൈലിയല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Even if you’ve never seen a runtime library initialization routine before, you can be pretty sure that it doesn’t end with a call to IsDebuggerPresent.","translation":"നിങ്ങൾ ഇതിനുമുമ്പ് ഒരു റൺടൈം ലൈബ്രറി പ്രാരംഭ ശൈലി കണ്ടിട്ടില്ലെങ്കിൽ പോലും, ഇത് IsDebuggerPresent എന്നതിലേക്ക് ഒരു കോളിനൊപ്പം അവസാനിക്കില്ലെന്ന് നിങ്ങൾക്ക് ഉറപ്പിക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"While we’re on that call, look at how EAX is being XORed against itself as soon as it returns.","translation":"നമ്മൾ ആ കോളിൽ ആയിരിക്കുമ്പോൾ, EAX മടങ്ങിയെത്തുമ്പോൾ തന്നെ എങ്ങനെയാണ് XOR ചെയ്യുന്നത് എന്ന് നോക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Its return value is being ignored!","translation":"അതിന്റെ റിട്ടേൺ മൂല്യം അവഗണിക്കുന്നു!","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"A quick look in http://msdn.microsoft.com shows us that IsDebugger Presentshould return a Boolean specifying whether a debugger is present or not.","translation":"http://msdn.microsoft.com-ൽ ഒരു quick ലുക്ക്, ഒരു ഡീബഗ്ഗർ ഉണ്ടോ ഇല്ലയോ എന്ന് വ്യക്തമാക്കുന്ന ഒരു ബൂളിയൻ IsDebuggerPresent നൽകണം എന്ന് കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"XORing EAX right after this API returns means that the call is meaningless.","translation":"ഈ API-ക്ക് ശേഷം EAX XOR ചെയ്യുന്നത് കോൾ അർത്ഥമില്ലാത്തതാണെന്ന് സൂചിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Anyway, let’s go back to the top of Listing 11.6 and learn something about Defender, starting with a call to 402EA8.","translation":"എന്തായാലും, ലിസ്റ്റിംഗ് 11.6-ന്റെ മുകളിലേക്ക് തിരികെ പോയി 402EA8 എന്നതിലേക്ക് ഒരു കോൾ ഉപയോഗിച്ച് തുടങ്ങുന്ന Defender-നെക്കുറിച്ച് ചില കാര്യങ്ങൾ പഠിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s take a look at what it does.","translation":"അത് എന്താണ് ചെയ്യുന്നതെന്ന് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The preceding routine starts out with an interesting sequence that loads a value from fs:30h.","translation":"മുമ്പത്തെ ശൈലി fs:30h-ൽ നിന്ന് ഒരു മൂല്യം ലോഡ് ചെയ്യുന്ന രസകരമായ ഒരു ശ്രേണിയോടെ ആരംഭിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Generally in NT-based operating systems the fs register is used for accessing thread local information.","translation":"സാധാരണയായി NT അടിസ്ഥാനമാക്കിയുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ, ത്രെഡ് ല local കൽ വിവരങ്ങൾ ആക്സസ് ചെയ്യാൻ fs രജിസ്റ്റർ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For any given thread, fs:0 points to the local TEB (Thread Environment Block) data structure, which contains a plethora of thread-private information required by the system during runtime.","translation":"ഏത് ത്രെഡിനും, fs:0 പ്രാദേശിക TEB (ത്രെഡ് എൻവയോൺമെന്റ് ബ്ലോക്ക്) ഡാറ്റാ ഘടനയിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു, ഇത് റൺടൈമിനിടയിൽ സിസ്റ്റത്തിന് ആവശ്യമായ ത്രെഡ്-സ്വകാര്യ വിവരങ്ങൾ ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In this case, the function is accessing offset +30.","translation":"ഈ സാഹചര്യത്തിൽ, ഫംഗ്ഷൻ ഓഫ്‌സെറ്റ് +30 ആക്സസ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Luckily, you have detailed symbolic information in Windows from which you can obtain information on what offset +30 is in the TEB.","translation":"ഭാഗ്യവശാൽ, വിൻഡോസിൽ നിങ്ങൾക്ക് വിശദമായ ചിഹ്ന വിവരങ്ങൾ ഉണ്ട്, അതിൽ നിന്ന് TEB-യിലെ ഓഫ്‌സെറ്റ് +30 എന്താണെന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ നിങ്ങൾക്ക് ലഭിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The structure listing for the TEB is quite long, so I’ll just list the first part of it, up to offset +30, which is the one being accessed by the program.","translation":"TEB-യുടെ ഘടനാപരമായ ലിസ്റ്റിംഗ് വളരെ വലുതാണ്, അതിനാൽ പ്രോഗ്രാം ആക്സസ് ചെയ്യുന്ന ഓഫ്‌സെറ്റ് +30 വരെയുള്ള ആദ്യ ഭാഗം ഞാൻ ലിസ്റ്റ് ചെയ്യാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It’s obvious that the first line is accessing the Process Environment Block through the TEB.","translation":"ആദ്യ വരി TEB വഴി പ്രോസസ് എൻവയോൺമെന്റ് ബ്ലോക്ക് ആക്സസ് ചെയ്യുന്നു എന്നത് വ്യക്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The PEB is the process-information data structure in Windows, just like the TEB is the thread information data structure.","translation":"TEB ത്രെഡ് വിവര ഡാറ്റാ ഘടന പോലെ, PEB വിൻഡോസിലെ പ്രോസസ്-വിവര ഡാറ്റാ ഘടനയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In address 00402EB5 the program is accessing offset +c in the PEB.","translation":"00402EB5 എന്ന വിലാസത്തിൽ പ്രോഗ്രാം PEB-യിലെ ഓഫ്‌സെറ്റ് +c ആക്സസ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Let’s look at what’s in there.","translation":"അവിടെ എന്താണുള്ളതെന്ന് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The first writes the current function’s checksum, and the second writes the exported function’s RVA (Rel- ative Virtual Address) into the same memory address plus 4.","translation":"ആദ്യത്തേത് നിലവിലെ ഫംഗ്‌ഷന്റെ ചെക്ക്‌സം എഴുതുന്നു, രണ്ടാമത്തേത് എക്‌സ്‌പോർട്ട് ചെയ്ത ഫംഗ്‌ഷന്റെ RVA (റിലേറ്റീവ് വെർച്വൽ വിലാസം) അതേ മെമ്മറി വിലാസത്തിൽ 4 ചേർത്ത് എഴുതുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This indicates that the newly allocated memory block contains an array of data structures, each 8 bytes long.","translation":"പുതുതായി അനുവദിച്ച മെമ്മറി ബ്ലോക്കിൽ ഡാറ്റാ ഘടനകളുടെ ഒരു ശ്രേണി അടങ്ങിയിരിക്കുന്നു എന്ന് ഇത് സൂചിപ്പിക്കുന്നു, ഓരോന്നിനും 8 ബൈറ്റ് വലുപ്പമുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Offset +0 contains a function name’s checksum, and offset +4 contains its RVA.","translation":"ഓഫ്‌സെറ്റ് +0 ഒരു ഫംഗ്‌ഷൻ നാമത്തിന്റെ ചെക്ക്‌സം ഉൾക്കൊള്ളുന്നു, കൂടാതെ ഓഫ്‌സെറ്റ് +4 അതിന്റെ RVA-യും ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This sequence performs a memory copy, and is a commonly seen “sentence” in assembly language.","translation":"ഈ ശ്രേണി ഒരു മെമ്മറി പകർപ്പ് നടത്തുന്നു, കൂടാതെ അസംബ്ലി ഭാഷയിൽ സാധാരണയായി കാണുന്ന ഒരു “വാക്യം” കൂടിയാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The second REP MOVS performs a byte-by-byte copying of the last 3 bytes if needed.","translation":"ആവശ്യമെങ്കിൽ അവസാനത്തെ 3 ബൈറ്റുകൾ ബൈറ്റ്-ബൈ-ബൈറ്റായി പകർപ്പായി രണ്ടാമത്തെ REP MOVS പ്രവർത്തിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Essentially, this sequence is copying all the code in NTDLL into this memory buffer.","translation":"അടിസ്ഥാനപരമായി, ഈ ശ്രേണി NTDLL-ലെ എല്ലാ കോഡുകളും ഈ മെമ്മറി ബഫറിലേക്ക് പകർത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is a mechanism that allocates a memory block at a random virtual address and creates what is essentially an obfuscated interface into the operating system module.","translation":"റാൻഡം വെർച്വൽ വിലാസത്തിൽ ഒരു മെമ്മറി ബ്ലോക്ക് അനുവദിക്കുകയും, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം മൊഡ്യൂളിലേക്ക് അവ്യക്തമായ ഒരു ഇന്റർഫേസ് ഉണ്ടാക്കുകയും ചെയ്യുന്ന ഒരു രീതിയാണിത്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This code contains a table of checksums of the names of all exported functions from NTDLL alongside their RVAs.","translation":"ഈ കോഡിൽ NTDLL-ൽ നിന്നുള്ള എല്ലാ എക്‌സ്‌പോർട്ട് ചെയ്ത ഫംഗ്‌ഷനുകളുടെയും പേരുകളുടെ ചെക്ക്‌സമ്മുകളുടെ ഒരു പട്ടികയും അവയുടെ RVA-കളും അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is a mechanism that allocates a memory block at a random virtual address and creates what is essentially an obfuscated interface into the operating system module.","translation":"ഇതൊരു മെക്കാനിസമാണ്, ഇത് ഒരു മെമ്മറി ബ്ലോക്ക് ഒരു ക്രമരഹിതമായ വെർച്വൽ വിലാസത്തിൽ അനുവദിക്കുകയും, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം മൊഡ്യൂളിലേക്ക് ഒരു അവ്യക്തമായ ഇന്റർഫേസ് ഉണ്ടാക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The code is looking for a specific API in NTDLL.","translation":"കോഡ് NTDLL-ൽ ഒരു പ്രത്യേക API-ക്കായി തിരയുകയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Because it’s not searching by strings but by this checksum you have no idea which API the code is looking for—the API’s name is just not available.","translation":"ഇത് സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് തിരയുന്നില്ല, എന്നാൽ ഈ ചെക്ക്‌സം ഉപയോഗിച്ച് തിരയുന്നതിനാൽ കോഡ് ഏത് API-യാണ് തിരയുന്നതെന്ന് നിങ്ങൾക്ക് അറിയില്ല - API-യുടെ പേര് ലഭ്യമല്ല.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This sequence performs a memory copy, and is a commonly seen “sentence” in assembly language.","translation":"ഈ ശ്രേണി ഒരു മെമ്മറി പകർപ്പ് നടത്തുന്നു, കൂടാതെ അസംബ്ലി ഭാഷയിൽ സാധാരണയായി കാണുന്ന ഒരു “വാക്യം” കൂടിയാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The function is taking the +4 offset of the found entry (remember that offset +4 contains the function’s RVA) and adding to that the address where NTDLL’s code section was copied.","translation":"കണ്ടെത്തിയ എൻട്രിയുടെ +4 ഓഫ്‌സെറ്റ് ഫംഗ്‌ഷൻ എടുക്കുന്നു (ഓഫ്‌സെറ്റ് +4-ൽ ഫംഗ്‌ഷന്റെ RVA അടങ്ങിയിരിക്കുന്നു എന്ന് ഓർക്കുക) കൂടാതെ NTDLL-ന്റെ കോഡ് വിഭാഗം പകർത്തിയ വിലാസം ഇതിലേക്ക് ചേർക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"No doubt this is a call into a copied version of an NTDLL API.","translation":"സംശയമില്ല, ഇത് NTDLL API-യുടെ പകർത്തിയ പതിപ്പിലേക്കുള്ള ഒരു കോളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Effectively, all KiFastSystemCalldoes is invoke the SYSENTERinstruction.","translation":"ഫലത്തിൽ, KiFastSystemCall ചെയ്യുന്നത് SYSENTER നിർദ്ദേശം വിളിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This means that the program executes a system call.","translation":"അതായത് പ്രോഗ്രാം ഒരു സിസ്റ്റം കോൾ എക്സിക്യൂട്ട് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"You obviously can’t step into SYSENTER because you’re using a user-mode debugger.","translation":"നിങ്ങൾ ഒരു ഉപയോക്തൃ-മോഡ് ഡീബഗ്ഗർ ഉപയോഗിക്കുന്നതിനാൽ, നിങ്ങൾക്ക് SYSENTER-ലേക്ക് പ്രവേശിക്കാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is another API call that goes through the bizarre copied NTDLL interface.","translation":"വിചിത്രമായ പകർത്തിയ NTDLL ഇന്റർഫേസിലൂടെ കടന്നുപോകുന്ന മറ്റൊരു API കോൾ ആണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It would appear that Defender wants to let the newly created thread start running immediately.","translation":"പുതുതായി സൃഷ്ടിച്ച ത്രെഡിനെ ഉടൻ തന്നെ പ്രവർത്തിക്കാൻ അനുവദിക്കാൻ ഡിഫൻഡർ ആഗ്രഹിക്കുന്നതായി തോന്നുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is an interesting function that appears to run an infinite loop.","translation":"അനന്തമായ ലൂപ്പ് പ്രവർത്തിക്കുന്നതായി തോന്നുന്ന ഒരു രസകരമായ ഫംഗ്‌ഷനാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"After a few minutes, you get the following output.","translation":"കുറച്ച് മിനിറ്റുകൾക്ക് ശേഷം, നിങ്ങൾക്ക് താഴെയുള്ള ഔട്ട്പുട്ട് ലഭിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Found our sequence! Key is 0xb14ac01a.","translation":"ഞങ്ങളുടെ ശ്രേണി കണ്ടെത്തി! കീ 0xb14ac01a ആണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This means that the correct serial can be calculated using Serial=LOW PART(NameSerial) * VolumeSerial – B14AC01A.","translation":"അതായത് ശരിയായ സീരിയൽ കണക്കാക്കാൻ Serial=LOW PART(NameSerial) * VolumeSerial – B14AC01A ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The question now is why is the serial 64 bits long?","translation":"ഇപ്പോൾ ചോദ്യം, എന്തുകൊണ്ടാണ് സീരിയൽ 64 ബിറ്റുകൾ long ആയിരിക്കുന്നത്?","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Let’s worry about that later.","translation":"അതിനെക്കുറിച്ച് പിന്നീട് ചിന്തിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"For now, you can create a little keygen program that will calculate a NameSerialand this algorithm and give you a (hope- fully) valid serial number that you can feed into Defender.","translation":"ഇപ്പോൾ, നിങ്ങൾക്ക് ഒരു ചെറിയ കീജെൻ പ്രോഗ്രാം ഉണ്ടാക്കാം, അത് ഒരു NameSerialand ഈ അൽഗോരിതം കണക്കുകൂട്ടുകയും നിങ്ങൾക്ക് ഡിഫൻഡറിലേക്ക് നൽകാൻ കഴിയുന്ന (പ്രതീക്ഷയോടെ) സാധുവായ സീരിയൽ നമ്പർ നൽകുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Converting a name string to a 64-bit number is done using the algorithm described in Figure 11.16.","translation":"ഒരു പേര് സ്ട്രിംഗിനെ 64-ബിറ്റ് നമ്പറാക്കി മാറ്റുന്നത് ചിത്രം 11.16-ൽ വിവരിച്ച അൽഗോരിതം ഉപയോഗിച്ചാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Here’s a C implementation of that algorithm.","translation":"ആ അൽഗോരിതത്തിന്റെ ഒരു C നടപ്പാക്കൽ ഇതാ.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This is the code for the keygen program.","translation":"ഇതാണ് കീജെൻ പ്രോഗ്രാമിനായുള്ള കോഡ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"When you run it with the name John Doe, you get the following output.","translation":"നിങ്ങൾ ഇത് ജോൺ ഡോ എന്ന പേരിൽ പ്രവർത്തിപ്പിക്കുമ്പോൾ, നിങ്ങൾക്ക് താഴെയുള്ള ഔട്ട്പുട്ട് ലഭിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Naturally, you’ll see different values because your volume serial number is different.","translation":"നിങ്ങളുടെ വോളിയം സീരിയൽ നമ്പർ വ്യത്യസ്തമായതിനാൽ, നിങ്ങൾ വ്യത്യസ്ത മൂല്യങ്ങൾ കാണും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The final number is what you have to feed into Defender.","translation":"അവസാന നമ്പർ ആണ് നിങ്ങൾ ഡിഫൻഡറിലേക്ക് നൽകേണ്ടത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Let’s see if it works!","translation":"ഇത് പ്രവർത്തിക്കുമോ എന്ന് നോക്കാം!","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"You type “John Doe” and 000000006482D9C6(or whatever your serial number is) as the command-line parameters and launch Defender.","translation":"കമാൻഡ്-ലൈൻ പാരാമീറ്ററുകളായി “John Doe” എന്നും 000000006482D9C6 (അല്ലെങ്കിൽ നിങ്ങളുടെ സീരിയൽ നമ്പർ എന്താണോ അത്) എന്നും ടൈപ്പ് ചെയ്ത് ഡിഫൻഡർ പ്രവർത്തിപ്പിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"No luck.","translation":"ഭാഗ്യമില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"You’re still getting the “Sorry” message.","translation":"നിങ്ങൾക്ക് ഇപ്പോഴും “ക്ഷമിക്കണം” എന്ന സന്ദേശം ലഭിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Looks like you’re going to have to step into that encrypted function and see what it does.","translation":"നിങ്ങൾ ആ എൻക്രിപ്റ്റ് ചെയ്ത ഫംഗ്ഷനിലേക്ക് പ്രവേശിച്ച് അത് എന്താണ് ചെയ്യുന്നതെന്ന് കാണേണ്ടിവരും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The encrypted function starts with a NtDelayExecutionand proceeds to call the inverse twin of that 64-bit left-shifter function you ran into earlier.","translation":"എൻക്രിപ്റ്റ് ചെയ്ത ഫംഗ്ഷൻ NtDelayExecution-ൽ ആരംഭിച്ച്, നിങ്ങൾ നേരത്തെ കണ്ട 64-ബിറ്റ് ലെഫ്റ്റ്-ഷിഫ്റ്റർ ഫംഗ്ഷന്റെ വിപരീത ഇരട്ടയെ വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This one does the same thing only with right shifts (32 of them to be exact).","translation":"ഇതൊരുപോലെ തന്നെ ചെയ്യുന്നത് റൈറ്റ് ഷിഫ്റ്റുകൾ ഉപയോഗിച്ചാണ് (കൃത്യമായി പറഞ്ഞാൽ 32 എണ്ണം).","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Defender is doing something you’ve seen it do before: It’s computing LOW PART(NameSerial) * VolumeSerial – HIGHPART(TypedSerial).","translation":"Defender മുമ്പ് ചെയ്ത ഒന്ന് ചെയ്യുന്നു: ഇത് LOW PART(NameSerial) * VolumeSerial – HIGHPART(TypedSerial) കണക്കുകൂട്ടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The CLR is the execution environment in which all .NET programs run.","translation":".NET പ്രോഗ്രാമുകളെല്ലാം പ്രവർത്തിക്കുന്ന ഒരു എക്സിക്യൂഷൻ എൻവയോൺമെന്റ് ആണ് CLR.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It consists of two primary components: the common language runtime (CLR) and the .NET class library.","translation":"ഇതിൽ രണ്ട് പ്രധാന ഘടകങ്ങൾ ഉണ്ട്: കോമൺ ലാംഗ്വേജ് റൺടൈം (CLR), .NET ക്ലാസ് ലൈബ്രറി എന്നിവയാണവ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The CLR loads and verifies .NET assemblies.","translation":"CLR .NET അസംബ്ലികൾ ലോഡ് ചെയ്യുകയും പരിശോധിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It is essentially a virtual machine inside which .NET programs are safely executed.","translation":".NET പ്രോഗ്രാമുകൾ സുരക്ഷിതമായി പ്രവർത്തിപ്പിക്കുന്ന ഒരു വെർച്വൽ മെഷീൻ ആണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The class library is what .NET programs use to communicate with the outside world.","translation":".NET പ്രോഗ്രാമുകൾക്ക് പുറം ലോകവുമായി ആശയവിനിമയം നടത്താൻ ഉപയോഗിക്കുന്ന ഒന്നാണ് ക്ലാസ് ലൈബ്രറി.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It offers services such as user-interface services, networking, and file I/O.","translation":"ഇത് ഉപയോക്തൃ ഇന്റർഫേസ് സേവനങ്ങൾ, നെറ്റ്‌വർക്കിംഗ്, ഫയൽ I/O തുടങ്ങിയ സേവനങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"A .NET binary module is referred to as an assembly.","translation":".NET ബൈനറി മൊഡ്യൂളിനെ അസംബ്ലി എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Assemblies contain a combination of IL code and associated metadata.","translation":"അസംബ്ലികളിൽ IL കോഡിന്റെയും അനുബന്ധ മെറ്റാഡാറ്റയുടെയും ഒരു സംയോജനമുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Metadata stores data type information describing the various objects used in the assembly.","translation":"അസംബ്ലിയിൽ ഉപയോഗിക്കുന്ന വിവിധ ഒബ്ജക്റ്റുകളെ വിവരിക്കുന്ന ഡാറ്റാ ടൈപ്പ് വിവരങ്ങൾ മെറ്റാഡാറ്റയിൽ സംഭരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Assemblies are executed by the common language runtime.","translation":"കോമൺ ലാംഗ്വേജ് റൺടൈം ഉപയോഗിച്ചാണ് അസംബ്ലികൾ എക്സിക്യൂട്ട് ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Managed code is verified by the CLR in runtime.","translation":"റൺടൈമിൽ CLR ആണ് മാനേജ്ഡ് കോഡ് പരിശോധിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Managed code consists of MSIL code and metadata.","translation":"മാനേജ്ഡ് കോഡിൽ MSIL കോഡും മെറ്റാഡാറ്റയും അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The CLR is aware of the data types that the program is dealing with.","translation":"പ്രോഗ്രാം കൈകാര്യം ചെയ്യുന്ന ഡാറ്റാ ടൈപ്പുകളെക്കുറിച്ച് CLR-ന് അറിയാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The metadata contains information about class definitions and methods.","translation":"മെറ്റാഡാറ്റയിൽ ക്ലാസ് നിർവചനങ്ങളെയും രീതികളെയും കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The CLR can easily check the size of the array and raise an exception if the index is out of bounds.","translation":"അറേയുടെ വലുപ്പം എളുപ്പത്തിൽ പരിശോധിക്കാനും സൂചിക പരിധിക്ക് പുറത്താണെങ്കിൽ ഒരു ഒഴിവാക്കൽ ഉണ്ടാക്കാനും CLR-ന് കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":".NET is not tied to any specific language.","translation":".NET ഏതെങ്കിലും പ്രത്യേക ഭാഷയുമായി ബന്ധിപ്പിച്ചിട്ടില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"C# was designed as the native .NET language.","translation":"C# രൂപകൽപ്പന ചെയ്തത് .NET-ന്റെ നേറ്റീവ് ഭാഷയായാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Both C# and Java are object oriented.","translation":"C# ഉം Java-യും ഒബ്ജക്റ്റ് ഓറിയന്റഡ് ആണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Visual Basic .NET programs now run using the CLR.","translation":"വിഷ്വൽ ബേസിക് .NET പ്രോഗ്രാമുകൾ ഇപ്പോൾ CLR ഉപയോഗിച്ചാണ് പ്രവർത്തിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Because of the presence of metadata, programs can interoperate at the object level.","translation":"മെറ്റാഡാറ്റയുടെ സാന്നിധ്യമുള്ളതിനാൽ, പ്രോഗ്രാമുകൾക്ക് ഒബ്ജക്റ്റ് തലത്തിൽ പരസ്പരം പ്രവർത്തിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"that brings us to what seems to be the end of this function.","translation":"ഇത് നമ്മെ ഈ ഫംഗ്ഷന്റെ അവസാനത്തിലേക്ക് എത്തിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"If you look closely at the address that the JMP at 004041F4 is going to you’ll notice that it’s very far from where you are at the moment—right at the begin- ning of this function actually.","translation":"JMP 004041F4-ൽ പോകുന്ന വിലാസം സൂക്ഷ്മമായി പരിശോധിച്ചാൽ, നിങ്ങൾ ഇപ്പോൾ നിൽക്കുന്ന സ്ഥലത്തുനിന്നും വളരെ ദൂരെയാണെന്നും, വാസ്തവത്തിൽ ഈ ഫംഗ്ഷന്റെ തുടക്കത്തിലാണെന്നും കാണാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Well, here’s the answer—there is encrypted code at the end of the function that sets this variable to zero and jumps back to that same position.","translation":"ശരി, ഇതാ ഉത്തരം - ഈ വേരിയബിൾ പൂജ്യമായി സജ്ജീകരിക്കുന്നതും അതേ സ്ഥാനത്തേക്ക് തിരികെ പോകുന്നതുമായ എൻക്രിപ്റ്റ് ചെയ്ത കോഡ് ഫംഗ്ഷന്റെ അവസാനത്തിലുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"After the encryption sequence ends, the fol- lowing code is executed:","translation":"എൻക്രിപ്ഷൻ സീക്വൻസ് അവസാനിച്ച ശേഷം, താഴെ പറയുന്ന കോഡ് എക്സിക്യൂട്ട് ചെയ്യും:","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The first line saves the value in EAX into a global variable.","translation":"ആദ്യ വരി EAX-ലെ മൂല്യം ഒരു ഗ്ലോബൽ വേരിയബിളിലേക്ക് സംരക്ഷിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Back at the Entry Point After the huge function you’ve just dissected returns, the entry point routine makes the traditional call into NtDelayExecution and calls into another internal function, at 404202.","translation":"വലിയ ഫംഗ്ഷൻ വിഭജിച്ച ശേഷം, എൻട്രി പോയിന്റ് റൂട്ടീൻ NtDelayExecution-ലേക്ക് ഒരു പരമ്പരാഗത കോൾ നടത്തുകയും 404202-ൽ മറ്റൊരു ആന്തരിക ഫംഗ്ഷനിലേക്ക് വിളിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This function performs another one of the familiar copied export table searches, this time on the copied KERNEL32 memory block (whose pointer is stored at 406004).","translation":"ഈ ഫംഗ്ഷൻ, പരിചയമുള്ള, പകർത്തിയ എക്സ്പോർട്ട് ടേബിൾ തിരയലുകളിൽ ഒന്ന് കൂടി നടത്തുന്നു, ഇത്തവണ KERNEL32 മെമ്മറി ബ്ലോക്കിലാണ് (പോയിന്റർ 406004-ൽ സംഭരിച്ചിരിക്കുന്നു).","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"You’ll use the function index trick that you used before in order to determine which API is being called.","translation":"ഏത് API-യാണ് വിളിക്കുന്നതെന്ന് നിർണ്ണയിക്കാൻ നിങ്ങൾ മുമ്പ് ഉപയോഗിച്ച ഫംഗ്ഷൻ ഇൻഡെക്സ് ട്രിക്ക് ഉപയോഗിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It looks like Defender is setting up 0040322E as its unhandled exception fil- ter.","translation":"Defender 0040322E ഒരു കൈകാര്യം ചെയ്യാത്ത എക്സെപ്ഷൻ ഫിൽട്ടറായി സജ്ജീകരിക്കുന്നതായി തോന്നുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Let’s proceed to another call to NtDelayExecution, followed by a call to another internal function, 401746.","translation":"നമുക്ക് NtDelayExecution-ലേക്ക് മറ്റൊരു കോളിലേക്ക് പോകാം, തുടർന്ന് മറ്റൊരു ആന്തരിക ഫംഗ്ഷനിലേക്ക്, 401746.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Before the code starts decrypting, the following two lines are executed:","translation":"കോഡ് ഡീക്രിപ്റ്റ് ചെയ്യാൻ തുടങ്ങുന്നതിന് മുമ്പ്, താഴെ പറയുന്ന രണ്ട് വരികൾ എക്സിക്യൂട്ട് ചെയ്യും:","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The reason I’m mentioning this is that the variable [EBP-9C0] is used a few lines later as the decryption key (the value against which the code is XORed to decrypt it).","translation":"ഇത് പറയാൻ കാരണമെന്തെന്നാൽ, [EBP-9C0] എന്ന വേരിയബിൾ കുറച്ച് വരികൾക്ക് ശേഷം ഡിക്രിപ്ഷൻ കീ ആയി ഉപയോഗിക്കുന്നു (കോഡ് ഡീക്രിപ്റ്റ് ചെയ്യാൻ XOR ചെയ്യുന്നത് ഈ മൂല്യത്തിനെതിരെയാണ്).","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Remember when the first encrypted function was about to return, how it reencrypted itself?","translation":"ആദ്യത്തെ എൻക്രിപ്റ്റ് ചെയ്ത ഫംഗ്ഷൻ തിരികെ വരാൻ പോകുമ്പോൾ, അത് എങ്ങനെയാണ് സ്വയം വീണ്ടും എൻക്രിപ്റ്റ് ചെയ്തതെന്ന് ഓർക്കുക?","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s proceed to investigate the newly decrypted function.","translation":"പുതുതായി ഡീക്രിപ്റ്റ് ചെയ്ത ഫംഗ്ഷൻ നമുക്ക് പരിശോധിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It starts with two calls to the traditional NtDelayExecution.","translation":"പരമ്പരാഗതമായ NtDelayExecution-ലേക്ക് രണ്ട് കോളുകളോടെയാണിത് ആരംഭിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This is a fairly typical copy protection sequence, in a slightly different flavor.","translation":"ഇതൊരു സാധാരണ കോപ്പി പ്രൊട്ടക്ഷൻ സീക്വൻസാണ്, അൽപ്പം വ്യത്യസ്തമായ രീതിയിൽ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The primary partition’s volume serial number is a good way to create com- puter-specific dependencies.","translation":"പ്രധാനപ്പെട്ട പാർട്ടീഷന്റെ വോളിയം സീരിയൽ നമ്പർ കമ്പ്യൂട്ടർ-നിർദ്ദിഷ്ട ഡിപ്പൻഡൻസികൾ ഉണ്ടാക്കാൻ നല്ലൊരു മാർഗ്ഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"You’ve pretty much reached the end of the current function.","translation":"നിങ്ങൾ നിലവിലെ ഫംഗ്ഷന്റെ അവസാനത്തിലെത്തിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Back at the main entry point function, you find another call to NtDelay Execution which is followed by a call into what appears to be the final func- tion call (other than that apparently useless call to IsDebuggerPresent) in the program entry point, 402082.","translation":"പ്രധാന എൻട്രി പോയിന്റ് ഫംഗ്ഷനിലേക്ക് മടങ്ങുമ്പോൾ, NtDelayExecution-ലേക്ക് മറ്റൊരു കോൾ കണ്ടെത്തുന്നു, തുടർന്ന് പ്രോഗ്രാം എൻട്രി പോയിന്റിലെ അവസാന ഫംഗ്ഷൻ കോളായി (IsDebuggerPresent-ലേക്കുള്ള ഉപയോഗശൂന്യമായ കോൾ ഒഴികെ) കാണപ്പെടുന്ന 402082-ലേക്ക് ഒരു കോൾ വരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"You immediately start seeing familiar bits of code (if Olly is still showing you junk instead of code at this point, you can either try stepping into that code and see if auto- matically fixes itself or you can specifically tell Olly to treat these bytes as code by right-clicking the first line and selecting Analysis. During next analysis, treat selection as➪Command).","translation":"നിങ്ങൾുടൻ തന്നെ പരിചിതമായ കോഡിന്റെ ഭാഗങ്ങൾ കാണാൻ തുടങ്ങും (ഈ ഘട്ടത്തിൽ Olly ഇപ്പോഴും കോഡിനുപകരം ജങ്ക് ആണ് കാണിക്കുന്നതെങ്കിൽ, ഒന്നുകിൽ ആ കോഡിലേക്ക് കടന്നുപോവുക, അത് സ്വയം ശരിയാകുമോയെന്ന് നോക്കുക അല്ലെങ്കിൽ ആദ്യ വരിയിൽ റൈറ്റ്-ക്ലിക്ക് ചെയ്ത് അനാലിസിസ് തിരഞ്ഞെടുത്ത് ഈ ബൈറ്റുകളെ കോഡായി കണക്കാക്കാൻ Olly-യോട് പ്രത്യേകം പറയുക. അടുത്ത വിശകലനത്തിൽ, സെലക്ഷനെ കമാൻഡായി പരിഗണിക്കണം).","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The code loads the reference to the newly created object into the first local variable.","translation":"പുതുതായി സൃഷ്ടിച്ച ഒബ്ജക്റ്റിന്റെ റഫറൻസ് ആദ്യത്തെ ലോക്കൽ വേരിയബിളിലേക്ക് കോഡ് ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is an excellent example of managed code functionality.","translation":"മാനേജ്ഡ് കോഡിന്റെ പ്രവർത്തനക്ഷമതയുടെ മികച്ച ഉദാഹരണമാണിത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Because the local variable’s data type is explicitly defined, the runtime can verify that the variable is being assigned a compatible data type.","translation":"ലോക്കൽ വേരിയബിളിന്റെ ഡാറ്റാ ടൈപ്പ് വ്യക്തമായി നിർവചിക്കപ്പെട്ടിരിക്കുന്നതിനാൽ, വേരിയബിളിന് അനുയോജ്യമായ ഡാറ്റാ ടൈപ്പ് നൽകിയിട്ടുണ്ടെന്ന് റൺടൈമിന് പരിശോധിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If there is an incompatibility the runtime will throw an exception.","translation":"അനുയോജ്യതയില്ലെങ്കിൽ റൺടൈം ഒരു ഒഴിവാക്കൽ എറിയും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The next code sequence at line IL_0006 loads 1 into V_1.","translation":"അടുത്ത കോഡ് സീക്വൻസ് IL_0006 വരിയിൽ V_1-ലേക്ക് 1 ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This sequence is very similar to the one in Listing 12.1, and is simply a posttested loop.","translation":"ഈ ശ്രേണി ലിസ്റ്റിംഗ് 12.1-ലേതിന് വളരെ സമാനമാണ്, കൂടാതെ ഇത് ഒരു പോസ്റ്റ്‌ടെസ്റ്റഡ് ലൂപ്പ് മാത്രമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Apparently V_1 is the counter, and it can go up to 10.","translation":"V_1 ആണ് കൗണ്ടർ, അത് 10 വരെ പോകാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Once it is above 10 the loop terminates.","translation":"10-ന് മുകളിലായാൽ ലൂപ്പ് അവസാനിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Here the method loads the string “item” into the stack, and then the value of V_1.","translation":"ഇവിടെ രീതി “item” എന്ന സ്ട്രിംഗും തുടർന്ന് V_1-ന്റെ മൂല്യവും സ്റ്റാക്കിലേക്ക് ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The value of V_1 is then boxed, which means that the runtime constructs an object that contains a copy of V_1 and pushes a reference to that object into the stack.","translation":"തുടർന്ന് V_1 ബോക്സ് ചെയ്യപ്പെടുന്നു, അതായത് റൺടൈം V_1-ന്റെ ഒരു പകർപ്പ് അടങ്ങിയ ഒരു ഒബ്ജക്റ്റ് നിർമ്മിക്കുകയും ആ ഒബ്ജക്റ്റിലേക്കുള്ള ഒരു റഫറൻസ് സ്റ്റാക്കിലേക്ക് തള്ളുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"An object has the advantage of having accurate type identification information associated with it.","translation":"കൃത്യമായ ടൈപ്പ് തിരിച്ചറിയൽ വിവരങ്ങൾ ഒരു ഒബ്ജക്റ്റിനുണ്ട് എന്നത് അതിന്റെ ഒരു നേട്ടമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"After boxing V_1, you wind up with two values on the stack: the string item and a reference to the boxed copy of V_1.","translation":"V_1 ബോക്സ് ചെയ്ത ശേഷം, നിങ്ങൾക്ക് സ്റ്റാക്കിൽ രണ്ട് മൂല്യങ്ങൾ ലഭിക്കും: item എന്ന സ്ട്രിംഗും V_1-ന്റെ ബോക്സ് ചെയ്ത കോപ്പിയുടെ റഫറൻസും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"These two values are then passed to class library method string [mscorlib]System. String:: Concat(object, object), which takes two items and constructs a single string out of them.","translation":"ഈ രണ്ട് മൂല്യങ്ങളും ക്ലാസ് ലൈബ്രറി രീതിയായ സ്ട്രിംഗ് [mscorlib]System. String:: Concat(object, object)-ലേക്ക് കൈമാറുന്നു, ഇത് രണ്ട് ഇനങ്ങളെ എടുത്ത് അവയിൽ നിന്ന് ഒരു സ്ട്രിംഗ് നിർമ്മിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If both objects are strings, the method will simply concatenate the two.","translation":"രണ്ട് ഒബ്ജക്റ്റുകളും സ്ട്രിംഗുകളാണെങ്കിൽ, രീതി രണ്ട് സ്ട്രിംഗുകളും ലളിതമായി ചേർക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Otherwise the function will convert both objects to strings and then perform the concatenation.","translation":"അല്ലാത്തപക്ഷം ഫംഗ്ഷൻ രണ്ട് ഒബ്ജക്റ്റുകളും സ്ട്രിംഗുകളിലേക്ക് പരിവർത്തനം ചെയ്യുകയും തുടർന്ന് കൂട്ടിച്ചേർക്കുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In this particular case, there is one string and one Int32, so the function will convert the Int32 to a string and then proceed to concatenate the two strings.","translation":"ഈ പ്രത്യേക സാഹചര്യത്തിൽ, ഒരു സ്ട്രിംഗും ഒരു Int32-ഉം ഉണ്ട്, അതിനാൽ ഫംഗ്ഷൻ Int32-നെ ഒരു സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യും, തുടർന്ന് രണ്ട് സ്ട്രിംഗുകളും കൂട്ടിച്ചേർക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The resulting string should look something like “itemX”, where X is the value of V_1.","translation":"ഫലമായുണ്ടാകുന്ന സ്ട്രിംഗ് “itemX” പോലെ കാണപ്പെടും, അവിടെ X എന്നത് V_1-ന്റെ മൂല്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"After constructing the string, the method allocates an instance of the object StringItem, and calls its constructor.","translation":"സ്ട്രിംഗ് നിർമ്മിച്ച ശേഷം, രീതി StringItem ഒബ്ജക്റ്റിന്റെ ഒരു ഇൻസ്റ്റൻസ് അനുവദിക്കുകയും അതിന്റെ കൺസ്ട്രക്റ്റർ വിളിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If you look at the prototype for the StringItem constructor, you can see that it takes a single parameter of type string.","translation":"StringItem കൺസ്ട്രക്റ്ററിനായുള്ള പ്രോട്ടോടൈപ്പ് നിങ്ങൾ പരിശോധിച്ചാൽ, ഇത് സ്ട്രിംഗ് ടൈപ്പിന്റെ ഒരൊറ്റ പാരാമീറ്റർ എടുക്കുമെന്ന് കാണാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Once the constructor returns newobj places a reference to the newly constructed object at the top of the stack, and the next line pops that reference from the stack into V_2.","translation":"കൺസ്ട്രക്റ്റർ തിരികെ എത്തിയ ശേഷം newobj പുതുതായി നിർമ്മിച്ച ഒബ്ജക്റ്റിലേക്കുള്ള ഒരു റഫറൻസ് സ്റ്റാക്കിന്റെ മുകളിൽ സ്ഥാപിക്കുന്നു, അടുത്ത വരി ആ റഫറൻസ് സ്റ്റാക്കിൽ നിന്ന് V_2-ലേക്ക് പോപ്പ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Some decompilers such as dcc have more than one intermediate representation.","translation":"dcc പോലുള്ള ചില ഡീകംപൈലറുകൾക്ക് ഒന്നിലധികം ഇടത്തരം പ്രാതിനിധ്യങ്ങളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Others use a single representation for the entire process.","translation":"മറ്റുള്ളവർ ഈ മുഴുവൻ പ്രക്രിയക്കും ഒരൊറ്റ പ്രാതിനിധ്യം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Assignment: This is a very generic instruction that represents an assignment operation.","translation":"അസൈൻമെന്റ്: ഇത് ഒരു അസൈൻമെന്റ് ഓപ്പറേഷനെ പ്രതിനിധീകരിക്കുന്ന വളരെ സാധാരണമായ ഒരു നിർദ്ദേശമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Push a value into the stack.","translation":"ഒരു മൂല്യം സ്റ്റാക്കിലേക്ക് തള്ളുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Pop a value from the stack.","translation":"സ്റ്റാക്കിൽ നിന്ന് ഒരു മൂല്യം പുറത്തെടുക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Call a subroutine and pass the listed parameters.","translation":"ഒരു ഉപവി routine വിളിക്കുകയും ലിസ്റ്റ് ചെയ്ത പാരാമീറ്ററുകൾ കൈമാറുകയും ചെയ്യുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Return from a subroutine.","translation":"ഒരു ഉപവി routine-ൽ നിന്ന് മടങ്ങുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Branch: A branch instruction evaluates two operands using a specified conditional code.","translation":"ബ്രാഞ്ച്: ഒരു ബ്രാഞ്ച് നിർദ്ദേശം ഒരു നിശ്ചിത conditional കോഡ് ഉപയോഗിച്ച് രണ്ട് ഓപ്പറാൻഡുകൾ വിലയിരുത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"An unconditional jump is a direct translation of the unconditional jump instruction.","translation":"ഒരു വ്യവസ്ഥകളില്ലാത്ത ജമ്പ്, വ്യവസ്ഥകളില്ലാത്ത ജമ്പ് നിർദ്ദേശത്തിന്റെ നേരിട്ടുള്ള വിവർത്തനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"One of the primary differences between assembly language and high-level languages is the ability of high-level languages to describe complex expressions.","translation":"അസംബ്ലി ഭാഷയും ഉയർന്ന തലത്തിലുള്ള ഭാഷകളും തമ്മിലുള്ള പ്രധാന വ്യത്യാസങ്ങളിലൊന്ന്, സങ്കീർണ്ണമായ എക്സ്പ്രഷനുകൾ വിവരിക്കാനുള്ള ഉയർന്ന തലത്തിലുള്ള ഭാഷകളുടെ കഴിവാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Consider the following C statement for instance.","translation":"ഉദാഹരണത്തിന്, താഴെ പറയുന്ന C സ്റ്റേറ്റ്മെന്റ് പരിഗണിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"One of the most important aspects of the decompilation process is the reconstruction of meaningful expressions.","translation":"ഡീകംപൈലേഷൻ പ്രക്രിയയുടെ ഏറ്റവും പ്രധാനപ്പെട്ട വശങ്ങളിലൊന്ന് അർത്ഥവത്തായ എക്സ്പ്രഷനുകളുടെ പുനർനിർമ്മാണമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The idea with this kind of tree is that it is an elegant structured representation of a sequence of arithmetic instructions.","translation":"ഇത്തരം ട്രീയുടെ ആശയം, ഇത് ഗണിത നിർദ്ദേശങ്ങളുടെ ഒരു ശ്രേണിയുടെ മനോഹരമായ ഘടനാപരമായ പ്രാതിനിധ്യമാണ് എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In order to reconstruct high-level control flow information from a low-level representation of a program, decompilers must create a control flow graph (CFG).","translation":"പ്രോഗ്രാമിന്റെ താഴ്ന്ന നിലയിലുള്ള പ്രാതിനിധ്യത്തിൽ നിന്ന് ഉയർന്ന തലത്തിലുള്ള കൺട്രോൾ ഫ്ലോ വിവരങ്ങൾ പുനർനിർമ്മിക്കുന്നതിന്, ഡീകംപൈലറുകൾ ഒരു കൺട്രോൾ ഫ്ലോ ഗ്രാഫ് (CFG) ഉണ്ടാക്കണം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Decompiler front ends perform the opposite function of compiler back ends.","translation":"ഡീകംപൈലർ ഫ്രണ്ട് എൻഡുകൾ, കംപൈലർ ബാക്ക് എൻഡുകളുടെ വിപരീത ധർമ്മം നിർവഹിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The first step in this process is to go over the source executable byte by byte.","translation":"ഈ പ്രക്രിയയിലെ ആദ്യത്തെ ഘട്ടം, സോഴ്സ് എക്സിക്യൂട്ടബിൾ ബൈറ്റ് ബൈറ്റായി പരിശോധിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Semantic Analysis: A decompiler front end starts out by simply scanning the individual instructions.","translation":"അർത്ഥപരമായ വിശകലനം: ഒരു ഡീകംപൈലർ ഫ്രണ്ട് എൻഡ് വ്യക്തിഗത നിർദ്ദേശങ്ങൾ സ്കാൻ ചെയ്തുകൊണ്ട് ആരംഭിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The front end must properly resolve these types of sequences.","translation":"ഫ്രണ്ട് എൻഡ് ഈ തരത്തിലുള്ള ശ്രേണികൾ ശരിയായി പരിഹരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Generating Control Flow Graphs: The code generated by a decompiler’s front end is represented in a graph structure.","translation":"നിയന്ത്രണ ഫ്ലോ ഗ്രാഫുകൾ ഉണ്ടാക്കുന്നു: ഒരു ഡീകംപൈലറിന്റെ ഫ്രണ്ട് എൻഡ് ഉണ്ടാക്കുന്ന കോഡ് ഒരു ഗ്രാഫ് ഘടനയിൽ പ്രതിനിധീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"After all, you’re looking to produce a high-level language representation from a binary executable.","translation":"എന്തായാലും, നിങ്ങൾ ഒരു ബൈനറി എക്സിക്യൂട്ടബിളിൽ നിന്ന് ഉയർന്ന തലത്തിലുള്ള ഭാഷാ പ്രാതിനിധ്യം ഉണ്ടാക്കാൻ ശ്രമിക്കുകയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This can get extremely annoying, especially considering that every class has at least one method called a.","translation":"എല്ലാ ക്ലാസുകൾക്കും a എന്ന് പേരുള്ള ഒരു മെത്തേഡ് എങ്കിലും ഉണ്ടാകുമെന്നതിനാൽ ഇത് വളരെ അധികം അരോചകമായേക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If you try to follow the control flow instructions in Listing 12.7, you’ll notice that they barely resemble the original flow of LinkedList::Dump.","translation":"ലിസ്റ്റിംഗ് 12.7-ലെ കൺട്രോൾ ഫ്ലോ നിർദ്ദേശങ്ങൾ പിന്തുടരാൻ ശ്രമിച്ചാൽ, അവ LinkedList::Dump-ൻ്റെ യഥാർത്ഥ ഒഴുക്കിനോട് വളരെ കുറഞ്ഞ സാമ്യമുള്ളതാണെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"DotFuscator can perform some fairly aggressive control flow obfuscation, depending on user settings.","translation":"ഉപയോക്തൃ ക്രമീകരണങ്ങളെ ആശ്രയിച്ച്, DotFuscator-ന് ചില ആക്രമണാത്മക നിയന്ത്രണ ഒഴുക്ക് അവ്യക്തമാക്കൽ നടത്താൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"First of all, the loop’s condition has been moved up to the beginning of the loop, and an unconditional jump back to the beginning of the loop has been added at the end.","translation":"ഒന്നാമതായി, ലൂപ്പിൻ്റെ അവസ്ഥ ലൂപ്പിൻ്റെ തുടക്കത്തിലേക്ക് മാറ്റിയിരിക്കുന്നു, കൂടാതെ ലൂപ്പിൻ്റെ തുടക്കത്തിലേക്ക് ഒരു വ്യവസ്ഥകളില്ലാത്ത ജമ്പ് അവസാനം ചേർത്തിട്ടുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If it’s not, the next instruction down is an unconditional jump that skips the loop’s body and goes to the end of the method.","translation":"അങ്ങനെയല്ലെങ്കിൽ, അടുത്ത നിർദ്ദേശം ലൂപ്പിൻ്റെ ഭാഗം ഒഴിവാക്കി രീതിയുടെ അവസാനം വരെ പോകുന്ന ഒരു വ്യവസ്ഥകളില്ലാത്ത ജമ്പാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It looks like the idea with that unconditional branch at IL_0007 is to complicate the control flow graph.","translation":"IL_0007-ലെ വ്യവസ്ഥകളില്ലാത്ത ബ്രാഞ്ചിൻ്റെ പിന്നിലെ ആശയം കൺട്രോൾ ഫ്ലോ ഗ്രാഫ് സങ്കീർണ്ണമാക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Let’s run this method through a decompiler and see whether these aggressive control flow obfuscation techniques impact the output from decompilers.","translation":"ഈ രീതി ഒരു ഡീകംപൈലറിലൂടെ പ്രവർത്തിപ്പിച്ച്, ഈ ആക്രമണാത്മക നിയന്ത്രണ ഒഴുക്ക് അവ്യക്തമാക്കൽ ടെക്നിക്കുകൾ ഡീകംപൈലറുകളിൽ നിന്നുള്ള ഔട്ട്‌പുട്ടിനെ ബാധിക്കുമോ എന്ന് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Spices. Net is completely confused by the unusual control flow constructs of this routine and generates incorrect code.","translation":"ഈ രീതിയുടെ അസാധാരണമായ കൺട്രോൾ ഫ്ലോ ഘടനയിൽ സ്പൈസസ്. നെറ്റ് പൂർണ്ണമായും ആശയക്കുഴപ്പത്തിലാവുകയും തെറ്റായ കോഡ് ഉണ്ടാക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It fails to properly identify the loop’s body and actually places the return statement inside the loop, even though it is executed after the loop.","translation":"ലൂപ്പിൻ്റെ ഭാഗം ശരിയായി തിരിച്ചറിയുന്നതിൽ ഇത് പരാജയപ്പെടുന്നു, കൂടാതെ ലൂപ്പിന് ശേഷം എക്സിക്യൂട്ട് ചെയ്യുമെങ്കിലും, റിട്ടേൺ സ്റ്റേറ്റ്മെൻ്റ് ലൂപ്പിനുള്ളിൽ സ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Different decompilers employ different control flow analysis algorithms, and they generally react differently to these types of control flow obfuscations.","translation":"വിവിധ ഡീകംപൈലറുകൾ വ്യത്യസ്ത കൺട്രോൾ ഫ്ലോ അനാലിസിസ് അൽഗോരിതങ്ങൾ ഉപയോഗിക്കുന്നു, കൂടാതെ ഈ തരത്തിലുള്ള കൺട്രോൾ ഫ്ലോ അവ്യക്തമാക്കലിനോട് അവ സാധാരണയായി വ്യത്യസ്തമായി പ്രതികരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"No problems here—Decompiler. Net does a good job and the obfuscated control flow structure of this routine seems to have no impact on its output.","translation":"ഇവിടെ പ്രശ്നങ്ങളൊന്നുമില്ല - ഡീകംപൈലർ. നെറ്റ് നല്ല രീതിയിൽ പ്രവർത്തിക്കുന്നു, കൂടാതെ ഈ രീതിയുടെ അവ്യക്തമായ കൺട്രോൾ ഫ്ലോ ഘടന അതിന്റെ ഔട്ട്‌പുട്ടിനെ ബാധിക്കാത്തതായി കാണുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is important to keep this in mind and to not overestimate the impact these techniques have on the overall readability of the program.","translation":"ഇത് മനസ്സിൽ വെക്കുകയും ഈ ടെക്നിക്കുകൾ പ്രോഗ്രാമിൻ്റെ മൊത്തത്തിലുള്ള വായനാക്ഷമതയിൽ ചെലുത്തുന്ന സ്വാധീനം അതിശയോക്തിപരമായി കാണാതിരിക്കുകയും ചെയ്യേണ്ടത് പ്രധാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is almost always going to be possible to correctly decompile control flow obfuscated code—after all the code always has to retain its original meaning in order for the program to execute properly.","translation":"കൺട്രോൾ ഫ്ലോ അവ്യക്തമാക്കിയ കോഡ് ശരിയായി ഡീകംപൈൽ ചെയ്യാൻ כഴിയും - എല്ലാത്തിനുമുപരി, പ്രോഗ്രാം ശരിയായി പ്രവർത്തിക്കുന്നതിന് കോഡിന് എപ്പോഴും അതിൻ്റെ യഥാർത്ഥ അർത്ഥം നിലനിർത്തേണ്ടതുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If you go back to the subject of symbol renaming, notice how confusing this simple alphabetical symbol naming scheme can be.","translation":"ചിഹ്നങ്ങളുടെ പുനർനാമകരണ വിഷയത്തിലേക്ക് മടങ്ങുകയാണെങ്കിൽ, ഈ ലളിതമായ അക്ഷരമാലാ ചിഹ്ന നാമകരണ രീതി എത്രത്തോളം ആശയക്കുഴപ്പമുണ്ടാക്കുമെന്നത് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Your a method belongs to class b, and there are two references to a: one this.a reference and another theD.a method call.","translation":"നിങ്ങളുടെ a രീതി b ക്ലാസുമായി ബന്ധപ്പെട്ടതാണ്, കൂടാതെ a-യിലേക്ക് രണ്ട് റഫറൻസുകളുണ്ട്: ഒന്ന് this.a റഫറൻസും മറ്റൊന്ന് theD.a രീതി വിളിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is an excellent example of where symbol renaming can have quite an annoying effect for reversers.","translation":"ചിഹ്നങ്ങളുടെ പുനർനാമകരണം റിവേഴ്സറുകൾക്ക് വളരെ അരോചകമായ ഫലം ഉണ്ടാക്കുന്നതിനുള്ള മികച്ച ഉദാഹരണമാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"While I’m dealing with symbol renaming, DotFuscator has another option that can cause additional annoyance to attackers trying to reverse obfuscated assemblies.","translation":"ചിഹ്നങ്ങളുടെ പുനർനാമകരണത്തെക്കുറിച്ച് പറയുമ്പോൾ തന്നെ, അവ്യക്തമാക്കിയ അസംബ്ലികൾ റിവേഴ്സ് ചെയ്യാൻ ശ്രമിക്കുന്ന ആക്രമണകാരികൾക്ക് കൂടുതൽ അസൗകര്യം ഉണ്ടാക്കുന്ന മറ്റൊരു ഓപ്ഷനും DotFuscator-ൽ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"It can rename symbols using invalid characters that cannot be properly displayed.","translation":"ശരിയായി പ്രദർശിപ്പിക്കാൻ കഴിയാത്ത അസാധുവായ പ്രതീകങ്ങൾ ഉപയോഗിച്ച് ഇതിന് ചിഹ്നങ്ങളുടെ പേര് മാറ്റാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This means that (depending on the tool that’s used for viewing the code) it might not even be possible to distinguish one symbol name from the other and that in some cases these characters might prevent certain tools from opening the assembly.","translation":"അതായത് (കോഡ് കാണുന്നതിന് ഉപയോഗിക്കുന്ന ടൂളിനെ ആശ്രയിച്ച്) ഒരു ചിഹ്നത്തിൻ്റെ പേര് മറ്റൊന്നിൽ നിന്ന് വേർതിരിച്ചറിയാൻ കഴിഞ്ഞെന്ന് വരില്ല, ചില സന്ദർഭങ്ങളിൽ ഈ പ്രതീകങ്ങൾ അസംബ്ലി തുറക്കുന്നതിൽ നിന്ന് ചില ടൂളുകളെ തടഞ്ഞേക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"As presented here, this function is pretty much impossible to decipher—it’s very difficult to differentiate between the different symbols.","translation":"ഇവിടെ അവതരിപ്പിച്ചതുപോലെ, ഈ ഫംഗ്ഷൻ മനസ്സിലാക്കാൻ ഏറെക്കുറെ അസാധ്യമാണ് - വ്യത്യസ്ത ചിഹ്നങ്ങളെ വേർതിരിക്കുന്നത് വളരെ ബുദ്ധിമുട്ടാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"For x * 4 or simply duplicate that expression wherever it is used.","translation":"x * 4 അല്ലെങ്കിൽ അത് ഉപയോഗിക്കുന്നിടത്തെല്ലാം ആ പദപ്രയോഗം പകർപ്പായി ഉപയോഗിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It should be noted that this is more of a style and readability issue that doesn’t really affect the meaning of the code.","translation":"ഇത് ശൈലിയുടെയും വായനാക്ഷമതയുടെയും പ്രശ്നമാണ്, ഇത് കോഡിന്റെ അർത്ഥത്തെ കാര്യമായി ബാധിക്കില്ല എന്നത് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Still, in very large functions that use highly complex expressions, it might make a significant impact on the overall readability of the generated code.","translation":"എങ്കിലും, വളരെ വലിയ ഫംഗ്ഷനുകളിൽ സങ്കീർണ്ണമായ പദപ്രയോഗങ്ങൾ ഉപയോഗിക്കുമ്പോൾ, ഇത് ഉണ്ടാക്കുന്ന കോഡിന്റെ മൊത്തത്തിലുള്ള വായനാക്ഷമതയിൽ കാര്യമായ സ്വാധീനം ചെലുത്തിയേക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Decompilers receive type information from a variety of sources and type-analysis techniques.","translation":"വിവിധ ഉറവിടങ്ങളിൽ നിന്നും ടൈപ്പ്-അനാലിസിസ് ടെക്നിക്കുകളിൽ നിന്നും ഡീകംപൈലറുകൾ ടൈപ്പ് വിവരങ്ങൾ സ്വീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Propagating that information throughout the program as much as possible can do wonders to improve the readability of decompiled output.","translation":"പ്രോഗ്രാം മുഴുവനും ഈ വിവരങ്ങൾ പരമാവധി പ്രചരിപ്പിക്കുന്നത് ഡീകംപൈൽ ചെയ്ത ഔട്ട്‌പുട്ടിന്റെ വായനാക്ഷമത മെച്ചപ്പെടുത്താൻ സഹായിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s take a powerful technique for extracting type information and demonstrate how it can benefit from type propagation.","translation":"ടൈപ്പ് വിവരങ്ങൾ എക്‌സ്‌ട്രാക്റ്റ് ചെയ്യുന്നതിനുള്ള ഒരു ശക്തമായ സാങ്കേതികവിദ്യ നമുക്ക് എടുക്കാം, കൂടാതെ ടൈപ്പ് പ്രചരണത്തിൽ നിന്ന് ഇതിന് എങ്ങനെ പ്രയോജനം നേടാനാകുമെന്ന് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is a well-known practice to gather data type information from library calls and system calls.","translation":"ലൈബ്രറി കോളുകളിൽ നിന്നും സിസ്റ്റം കോളുകളിൽ നിന്നും ഡാറ്റാ ടൈപ്പ് വിവരങ്ങൾ ശേഖരിക്കുന്നത് ഒരു സാധാരണ രീതിയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The idea is that if you can properly identify calls to known functions such as system calls or runtime library calls, you can easily propagate data types throughout the program and greatly improve its readabil- ity.","translation":"സിസ്റ്റം കോളുകൾ അല്ലെങ്കിൽ റൺടൈം ലൈബ്രറി കോളുകൾ പോലുള്ള അറിയപ്പെടുന്ന ഫംഗ്ഷനുകളിലേക്കുള്ള കോളുകൾ നിങ്ങൾക്ക് ശരിയായി തിരിച്ചറിയാൻ കഴിയുമെങ്കിൽ, പ്രോഗ്രാം മുഴുവനും ഡാറ്റാ ടൈപ്പുകൾ എളുപ്പത്തിൽ പ്രചരിപ്പിക്കാനും അതിന്റെ വായനാക്ഷമത വളരെയധികം മെച്ചപ്പെടുത്താനും കഴിയും എന്നതാണ് ആശയം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"First let’s consider the simple case of external calls made to known system functions such as KERNEL32!CreateFileA.","translation":"ആദ്യം KERNEL32!CreateFileA പോലുള്ള അറിയപ്പെടുന്ന സിസ്റ്റം ഫംഗ്ഷനുകളിലേക്ക് നടത്തുന്ന ബാഹ്യ കോളുകളുടെ ലളിതമായ കേസ് പരിഗണിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Upon encountering such a call, a decompiler can greatly benefit from the type information known about the call.","translation":"അത്തരം ഒരു കോൾ കണ്ടെത്തുമ്പോൾ, കോളിനെക്കുറിച്ച് അറിയാവുന്ന ടൈപ്പ് വിവരങ്ങളിൽ നിന്ന് ഒരു ഡീകംപൈലറിന് വളരെയധികം പ്രയോജനം നേടാനാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For example, for this particular API it is known that its return value is a file han- dle and that the first parameter it receives is a pointer to an ASCII file name.","translation":"ഉദാഹരണത്തിന്, ഈ പ്രത്യേക API-യുടെ റിട്ടേൺ മൂല്യം ഒരു ഫയൽ ഹാൻഡിലാണെന്നും, ഇത് സ്വീകരിക്കുന്ന ആദ്യത്തെ പാരാമീറ്റർ ഒരു ASCII ഫയൽ നാമത്തിലേക്കുള്ള പോയിന്റർ ആണെന്നും അറിയപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This information can be propagated within the current procedure to improve its readability because you now know that the register or storage location from which the first parameter is taken contains a pointer to a file name string.","translation":"ആദ്യത്തെ പാരാമീറ്റർ എടുക്കുന്ന രജിസ്റ്ററോ സ്റ്റോറേജ് ലൊക്കേഷനോ ഒരു ഫയൽ നാമ സ്‌ട്രിംഗിലേക്കുള്ള പോയിന്റർ ഉൾക്കൊള്ളുന്നു എന്ന് ഇപ്പോൾ നിങ്ങൾക്ക് അറിയുന്നതിനാൽ, അതിന്റെ വായനാക്ഷമത മെച്ചപ്പെടുത്തുന്നതിന് ഈ വിവരങ്ങൾ നിലവിലെ നടപടിക്രമത്തിനുള്ളിൽ പ്രചരിപ്പിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Depending on where this value comes from, you can enhance the program’s type information.","translation":"ഈ മൂല്യം എവിടെ നിന്നാണ് വരുന്നതെന്നതിനെ ആശ്രയിച്ച്, നിങ്ങൾക്ക് പ്രോഗ്രാമിന്റെ ടൈപ്പ് വിവരങ്ങൾ മെച്ചപ്പെടുത്താൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If for instance the value comes from a parameter passed to the current procedure, you now know the type of this parameter, and so on.","translation":"ഉദാഹരണത്തിന്, മൂല്യം നിലവിലെ നടപടിക്രമത്തിലേക്ക് കൈമാറിയ ഒരു പാരാമീറ്ററിൽ നിന്നാണ് വരുന്നതെങ്കിൽ, നിങ്ങൾക്ക് ഇപ്പോൾ ഈ പാരാമീറ്ററിന്റെ തരം അറിയാം, അങ്ങനെ തുടരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In a similar way, the value returned from this function can be tracked and correctly typed throughout this procedure and beyond.","translation":"ഇതേ രീതിയിൽ, ഈ ഫംഗ്ഷനിൽ നിന്ന് തിരികെ ലഭിക്കുന്ന മൂല്യം ഈ നടപടിക്രമത്തിലുടനീളവും അതിനപ്പുറവും ട്രാക്ക് ചെയ്യാനും ശരിയായി ടൈപ്പ് ചെയ്യാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If the return value is used by the caller of the current procedure, you now know that the procedure also returns a file handle type.","translation":"നിലവിലെ നടപടിക്രമത്തിന്റെ കോളർ റിട്ടേൺ മൂല്യം ഉപയോഗിക്കുകയാണെങ്കിൽ, നടപടിക്രമം ഒരു ഫയൽ ഹാൻഡിൽ തരവും നൽകുന്നു എന്ന് നിങ്ങൾ ഇപ്പോൾക്കറിയാം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This process is most effective when it is performed globally, on the entire program.","translation":"പ്രോഗ്രാം മുഴുവനും, ഇത് ആഗോളതലത്തിൽ നടപ്പിലാക്കുമ്പോളാണ് ഈ പ്രക്രിയ ഏറ്റവും ഫലപ്രദമാകുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"That’s because the decompiler can recursively propagate type infor- mation throughout the program and thus significantly improve overall output quality.","translation":"കാരണം, ഡീകംപൈലറിന് പ്രോഗ്രാം മുഴുവനും ടൈപ്പ് വിവരങ്ങൾ ആവർത്തിച്ച് പ്രചരിപ്പിക്കാൻ കഴിയും, അതുവഴി മൊത്തത്തിലുള്ള ഔട്ട്‌പുട്ട് നിലവാരം ഗണ്യമായി മെച്ചപ്പെടുത്താനാകും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Consider the call to CreateFileAfrom above.","translation":"മുകളിൽ കൊടുത്ത CreateFileA-യിലേക്കുള്ള കോൾ പരിഗണിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"If you propagate all type information deduced from this call to both callers and callees of the current procedure, you wind up with quite a bit of additional type information throughout the program.","translation":"ഈ കോളിൽ നിന്ന് ലഭിച്ച എല്ലാ ടൈപ്പ് വിവരങ്ങളും നിലവിലെ നടപടിക്രമത്തിന്റെ കോളർമാരിലേക്കും കാളീസുകളിലേക്കും നിങ്ങൾ പ്രചരിപ്പിക്കുകയാണെങ്കിൽ, പ്രോഗ്രാം മുഴുവനും ധാരാളം അധിക ടൈപ്പ് വിവരങ്ങൾ ലഭിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The compiler adds extra conditional jumps when conditions are connected using an OR operator.","translation":"ഒരു അല്ലെങ്കിൽ ഓപ്പറേറ്റർ ഉപയോഗിച്ച് വ്യവസ്ഥകൾ ബന്ധിപ്പിക്കുമ്പോൾ, കംപൈലർ അധിക വ്യവസ്ഥാപരമായ ജമ്പുകൾ ചേർക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The compiler will always place an unconditional jump right after the final conditional branch instruction.","translation":"അവസാനത്തെ വ്യവസ്ഥാപരമായ ബ്രാഞ്ച് നിർദ്ദേശത്തിന് ശേഷം കംപൈലർ എപ്പോഴും ഒരു വ്യവസ്ഥകളില്ലാത്ത ജമ്പ് സ്ഥാപിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This unconditional jump will skip the conditional block.","translation":"ഈ വ്യവസ്ഥകളില്ലാത്ത ജമ്പ് വ്യവസ്ഥാപരമായ ബ്ലോക്ക് ഒഴിവാക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The last condition is reversed in the more optimized technique.","translation":"കൂടുതൽ ഒപ്റ്റിമൈസ് ചെയ്ത സാങ്കേതികതയിൽ അവസാന വ്യവസ്ഥ വിപരീതമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The rest of the conditions are implemented as straight conditional jumps.","translation":"മറ്റ് വ്യവസ്ഥകളെല്ലാം നേരായ വ്യവസ്ഥാപരമായ ജമ്പുകളായി നടപ്പിലാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"When multiple OR operators are used, the compiler will produce multiple consecutive conditional jumps.","translation":"ഒന്നിലധികം അല്ലെങ്കിൽ ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കുമ്പോൾ, കംപൈലർ ഒന്നിലധികം തുടർച്ചയായ വ്യവസ്ഥാപരമായ ജമ്പുകൾ ഉണ്ടാക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The last condition will be reversed and will jump to the code right after the conditional block.","translation":"അവസാനത്തെ വ്യവസ്ഥ വിപരീതമാക്കുകയും വ്യവസ്ഥാപരമായ ബ്ലോക്കിന് തൊട്ടുപിന്നാലെയുള്ള കോഡിലേക്ക് ജമ്പ് ചെയ്യുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"When more than two conditions are combined using the AND operator, the compiler adds more reversed conditions.","translation":"രണ്ടിൽ കൂടുതൽ വ്യവസ്ഥകൾ AND ഓപ്പറേറ്റർ ഉപയോഗിച്ച് സംയോജിപ്പിക്കുമ്പോൾ, കംപൈലർ കൂടുതൽ വിപരീത വ്യവസ്ഥകൾ ചേർക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"High-level programming languages allow programmers to combine any number of conditions using logical operators.","translation":"ഉയർന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷകൾക്ക് ലോജിക്കൽ ഓപ്പറേറ്റർമാർ ഉപയോഗിച്ച് എത്ര എണ്ണം വ്യവസ്ഥകളും സംയോജിപ്പിക്കാൻ പ്രോഗ്രാമർമാരെ അനുവദിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Conditions combined using the OR operator will usually jump directly to the conditional code block.","translation":"അല്ലെങ്കിൽ ഓപ്പറേറ്റർ ഉപയോഗിച്ച് സംയോജിപ്പിച്ച വ്യവസ്ഥകൾ സാധാരണയായി നേരിട്ട് വ്യവസ്ഥാപരമായ കോഡ് ബ്ലോക്കിലേക്ക് ജമ്പ് ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In contrast, conditions combined using the AND operator will tend to be reversed.","translation":"നേരെമറിച്ച്, AND ഓപ്പറേറ്റർ ഉപയോഗിച്ച് സംയോജിപ്പിച്ച വ്യവസ്ഥകൾ വിപരീതമാക്കാൻ സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Switch blocks are commonly used when different behavior is required for different values.","translation":"വ്യത്യസ്ത മൂല്യങ്ങൾക്ക് വ്യത്യസ്ത പെരുമാറ്റം ആവശ്യമായി വരുമ്പോൾ സ്വിച്ച് ബ്ലോക്കുകൾ സാധാരണയായി ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Compilers have several methods for dealing with switch blocks.","translation":"സ്വിച്ച് ബ്ലോക്കുകൾ കൈകാര്യം ചെയ്യാൻ കംപൈലറുകൾക്ക് നിരവധി രീതികളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The most efficient approach for large switch blocks is to generate a pointer table.","translation":"വലിയ സ്വിച്ച് ബ്ലോക്കുകൾക്കുള്ള ഏറ്റവും കാര്യക്ഷമമായ സമീപനം ഒരു പോയിന്റർ പട്ടിക ഉണ്ടാക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The compiler subtracts 1 from ByteValue and compares it to 4.","translation":"കംപൈലർ ബൈറ്റ് മൂല്യത്തിൽ നിന്ന് 1 കുറയ്ക്കുകയും അത് 4-മായി താരതമ്യം ചെയ്യുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This JMP uses a dynamically calculated memory address.","translation":"ഈ JMP ഒരു ഡൈനാമിക്കായി കണക്കാക്കിയ മെമ്മറി വിലാസം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The compiler implements a binary tree search strategy to reach the desired item.","translation":"ആവശ്യമുള്ള ഇനത്തിൽ എത്തിച്ചേരാൻ കംപൈലർ ഒരു ബൈനറി ട്രീ തിരയൽ തന്ത്രം നടപ്പിലാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The general idea is to divide the searchable items into two equally sized groups.","translation":"തിരയാൻ കഴിയുന്ന ഇനങ്ങളെ തുല്യ വലുപ്പമുള്ള രണ്ട് ഗ്രൂപ്പുകളായി വിഭജിക്കുക എന്നതാണ് പൊതുവായ ആശയം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Loops typically include a counter to control the number of iterations.","translation":"ചക്രങ്ങൾ സാധാരണയായി ആവർത്തനങ്ങളുടെ എണ്ണം നിയന്ത്രിക്കാൻ ഒരു കൗണ്ടർ ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Pretested loops are probably the most popular loop construct.","translation":"മുമ്പേ പരിശോധിച്ച ലൂപ്പുകളാണ് ഒരുപക്ഷേ ഏറ്റവും പ്രചാരമുള്ള ലൂപ്പ് ഘടന.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The program tests one or more logical conditions, and branches to a different part of the program based on the result of the logical test.","translation":"പ്രോഗ്രാം ഒന്നോ അതിലധികമോ ലോജിക്കൽ അവസ്ഥകൾ പരിശോധിക്കുകയും ലോജിക്കൽ ടെസ്റ്റിന്റെ ഫലത്തെ ആശ്രയിച്ച് പ്രോഗ്രാമിന്റെ വ്യത്യസ്ത ഭാഗങ്ങളിലേക്ക് ബ്രാഞ്ച് ചെയ്യുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Identifying branches and figuring out their meaning and purpose is one of the most basic code-level reversing tasks.","translation":"ബ്രാഞ്ചുകൾ തിരിച്ചറിയുകയും അവയുടെ അർത്ഥവും ഉദ്ദേശ്യവും കണ്ടെത്തുകയും ചെയ്യുക എന്നത് കോഡ് ലെവൽ റിവേഴ്സിംഗ് ടാസ്‌ക്കുകളിൽ ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"From a reversing standpoint functions are very easy to detect because of function prologues and epilogues.","translation":"ഒരു റിവേഴ്സിംഗ് വീക്ഷണകോണിൽ നിന്ന് നോക്കുമ്പോൾ, ഫംഗ്ഷൻ പ്രൊലോഗുകളും എപ്പിലോഗുകളും കാരണം ഫംഗ്ഷനുകൾ കണ്ടെത്തുന്നത് വളരെ എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"These are standard initialization sequences that compilers generate for nearly every function.","translation":"ഏതാണ്ട് എല്ലാ ഫംഗ്ഷനുകൾക്കും കംപൈലറുകൾ ഉണ്ടാക്കുന്ന സാധാരണമായ പ്രാരംഭ ശ്രേണികളാണിവ.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"On IA-32 processors function are nearly always called using the CALL instruction, which stores the current instruction pointer in the stack and jumps to the function address.","translation":"IA-32 പ്രോസസ്സറുകളിൽ, CALL ഇൻസ്ട്രക്ഷൻ ഉപയോഗിച്ചാണ് ഫംഗ്ഷനുകൾ സാധാരണയായി വിളിക്കപ്പെടുന്നത്, ഇത് നിലവിലെ ഇൻസ്ട്രക്ഷൻ പോയിന്റർ സ്റ്റാക്കിൽ സംഭരിക്കുകയും ഫംഗ്ഷൻ വിലാസത്തിലേക്ക് ജമ്പ് ചെയ്യുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This makes it easy to distinguish function calls from other unconditional jumps.","translation":"ഇത് ഫംഗ്ഷൻ കോളുകളെ മറ്റ് നിരുപാധിക ജമ്പുകളിൽ നിന്ന് വേർതിരിക്കുന്നത് എളുപ്പമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"When compilers generate an internal function call sequence they usually just embed the function’s address into the code, which makes it very easy to detect.","translation":"കംപൈലറുകൾ ഒരു ഇന്റേണൽ ഫംഗ്ഷൻ കോൾ സീക്വൻസ് ഉണ്ടാക്കുമ്പോൾ, അവർ സാധാരണയായി ഫംഗ്ഷന്റെ വിലാസം കോഡിലേക്ക് ഉൾപ്പെടുത്തുന്നു, ഇത് കണ്ടെത്തുന്നത് വളരെ എളുപ്പമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"An imported function call takes place when a module is making a call into a function implemented in another binary executable.","translation":"ഒരു മൊഡ്യൂൾ മറ്റൊരു ബൈനറി എക്സിക്യൂട്ടബിളിൽ നടപ്പിലാക്കിയ ഒരു ഫംഗ്ഷനിലേക്ക് കോൾ ചെയ്യുമ്പോൾ ഒരു ഇറക്കുമതി ചെയ്ത ഫംഗ്ഷൻ കോൾ നടക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Imported function calls are implemented using the Import Directory and Import Address Table.","translation":"ഇറക്കുമതി ചെയ്ത ഫംഗ്ഷൻ കോളുകൾ ഇംപോർട്ട് ഡയറക്ടറിയും ഇംപോർട്ട് അഡ്രസ്സ് ടേബിളും ഉപയോഗിച്ചാണ് നടപ്പിലാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The import directory is used in runtime for resolving the function’s name with a matching function in the target executable, and the IAT stores the actual address of the target function.","translation":"ടാർഗെറ്റ് എക്സിക്യൂട്ടബിളിലെ ഒരു പൊരുത്തപ്പെടുന്ന ഫംഗ്ഷനുമായി ഫംഗ്ഷന്റെ പേര് പരിഹരിക്കുന്നതിന് റൺടൈമിൽ ഇംപോർട്ട് ഡയറക്ടറി ഉപയോഗിക്കുന്നു, കൂടാതെ IAT ടാർഗെറ്റ് ഫംഗ്ഷന്റെ യഥാർത്ഥ വിലാസം സംഭരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The caller then loads the function’s pointer from the IAT and calls it.","translation":"തുടർന്ന് കോളർ IAT-യിൽ നിന്ന് ഫംഗ്ഷന്റെ പോയിന്റർ ലോഡ് ചെയ്ത് അതിനെ വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Detecting imported calls is easy because except for these types of calls, functions are rarely called indirectly through a hard-coded function pointer.","translation":"ഇത്തരം കോളുകൾ ഒഴികെ, ഫംഗ്ഷനുകൾ വളരെ അപൂർവമായി മാത്രമേ ഒരു ഹാർഡ്-കോഡ് ചെയ്ത ഫംഗ്ഷൻ പോയിന്റർ വഴി നേരിട്ടല്ലാതെ വിളിക്കപ്പെടാറുള്ളൂ എന്നതുകൊണ്ട് ഇറക്കുമതി ചെയ്ത കോളുകൾ കണ്ടെത്തുന്നത് എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The most basic form of logic in most programs consists of a condition and an ensuing conditional branch.","translation":"മിക്ക പ്രോഗ്രാമുകളിലെയും ഏറ്റവും അടിസ്ഥാനപരമായ ലോജിക് ഒരു അവസ്ഥയും തുടർന്ന് ഉണ്ടാകുന്ന ഒരു വ്യവസ്ഥാപിത ബ്രാഞ്ചും ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In high-level languages, this is written as an if statement with a condition and a block of conditional code that gets executed if the condition is satisfied.","translation":"ഉയർന്ന തലത്തിലുള്ള ഭാഷകളിൽ, ഇത് ഒരു അവസ്ഥയും, അവസ്ഥ ശരിയാണെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യുന്ന ഒരു വ്യവസ്ഥാപിത കോഡിന്റെ ബ്ലോക്കും ഉൾപ്പെടുന്ന ഒരു if സ്റ്റേറ്റ്‌മെന്റായി എഴുതുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"From a low-level perspective, implementing this statement requires a logical check to determine whether SomeVariable contains 0 or not, followed by code that skips the conditional block by performing a conditional jump if SomeVariable is nonzero.","translation":"ഒരു താഴ്ന്ന തലത്തിലുള്ള വീക്ഷണകോണിൽ നിന്ന്, ഈ സ്റ്റേറ്റ്‌മെന്റ് നടപ്പിലാക്കാൻ, SomeVariable 0 ആണോ അല്ലയോ എന്ന് നിർണ്ണയിക്കാൻ ഒരു ലോജിക്കൽ പരിശോധന ആവശ്യമാണ്, തുടർന്ന് SomeVariable പൂജ്യമല്ലാത്തതാണെങ്കിൽ വ്യവസ്ഥാപിത ബ്ലോക്ക് ഒഴിവാക്കുന്ന കോഡ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In the source code, the program was checking whether SomeVariable equals zero, but the compiler reversed the condition so that the conditional instruction checks whether SomeVariable is nonzero.","translation":"സോഴ്സ് കോഡിൽ, പ്രോഗ്രാം SomeVariable പൂജ്യത്തിന് തുല്യമാണോ എന്ന് പരിശോധിക്കുകയായിരുന്നു, എന്നാൽ കംപൈലർ ഈ അവസ്ഥ വിപരീതമാക്കി, അതുവഴി വ്യവസ്ഥാപിത നിർദ്ദേശം SomeVariable പൂജ്യമല്ലാത്തതാണോ എന്ന് പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This stems from the fact that the compiler-generated binary code is organized in memory in the same order as it is organized in the source code.","translation":"കംപൈലർ ഉണ്ടാക്കിയ ബൈനറി കോഡ് സോഴ്സ് കോഡിൽ ഓർഗനൈസ് ചെയ്ത അതേ ക്രമത്തിലാണ് മെമ്മറിയിൽ ഓർഗനൈസ് ചെയ്തിരിക്കുന്നത് എന്ന വസ്തുതയിൽ നിന്നാണ് ഇത് ഉണ്ടാകുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Therefore if SomeVariable is nonzero, the compiler must skip the conditional code section and go straight to the code section that follows.","translation":"അതുകൊണ്ട് SomeVariable പൂജ്യമല്ലാത്തതാണെങ്കിൽ, കംപൈലർ വ്യവസ്ഥാപിത കോഡ് വിഭാഗം ഒഴിവാക്കുകയും തുടർന്ന് വരുന്ന കോഡ് വിഭാഗത്തിലേക്ക് നേരിട്ട് പോവുകയും വേണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The basic pattern to look for when trying to detect a simple ‘if-else’ statement in a disassembled program is a condition where the code that follows it ends with an unconditional jump.","translation":"ഒരു ഡിസ്അസംബിൾ ചെയ്ത പ്രോഗ്രാമിൽ ലളിതമായ ‘if-else’ സ്റ്റേറ്റ്‌മെന്റ് കണ്ടെത്താൻ ശ്രമിക്കുമ്പോൾ ശ്രദ്ധിക്കേണ്ട അടിസ്ഥാന പാറ്റേൺ, അതിനെ പിന്തുടരുന്ന കോഡ് ഒരു നിരുപാധിക ജമ്പിൽ അവസാനിക്കുന്ന ഒരു അവസ്ഥയാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"A two-way conditional is different from a single-branch conditional in the sense that if the condition is not satisfied, the program executes an alternative code block and only then proceeds to the code that follows the ‘if-else’ statement.","translation":"ഒരു ദ്വിമുഖ വ്യവസ്ഥ, വ്യവസ്ഥ തൃപ്തികരമല്ലാത്ത പക്ഷം, പ്രോഗ്രാം ഒരു ഇതര കോഡ് ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുകയും തുടർന്ന് ‘if-else’ സ്റ്റേറ്റ്‌മെന്റിന് ശേഷമുള്ള കോഡിലേക്ക് പോവുകയും ചെയ്യുന്ന അർത്ഥത്തിൽ, ഏക ബ്രാഞ്ച് വ്യവസ്ഥയിൽ നിന്ന് വ്യത്യസ്തമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The compiler uses arithmetic and conditional instructions to reduce the number of jumps.","translation":"ജം‌പുകളുടെ എണ്ണം കുറയ്ക്കാൻ വേണ്ടി, കംപൈലർ ഗണിതപരവും, വ്യവസ്ഥാപിതവുമായ നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"These optimizations are usually applied to code that performs arithmetic operations on operands.","translation":"ഓപ്പറാൻ്റുകളിൽ ഗണിത പ്രവർത്തനങ്ങൾ നടപ്പിലാക്കുന്ന കോഡിനാണ് സാധാരണയായി ഈ ഒപ്റ്റിമൈസേഷനുകൾ ബാധകമാവുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The idea is to convert conditional execution paths into a single sequence of arithmetic operations.","translation":"വ്യവസ്ഥാപിത നിർവ്വഹണ വഴികൾ, ഗണിത പ്രവർത്തനങ്ങളുടെ ഒരൊറ്റ ശ്രേണിയിലേക്ക് മാറ്റുക എന്നതാണ് ഇതിൻ്റെ ആശയം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Compilers sometimes employ special conditional instructions for more involved logical statements.","translation":"കൂടുതൽ സങ്കീർണ്ണമായ ലോജിക്കൽ സ്റ്റേറ്റ്‌മെന്റുകൾക്കായി, കംപൈലറുകൾ ചിലപ്പോൾ പ്രത്യേക വ്യവസ്ഥാപിത നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"One is based on converting logic into a purely arithmetic sequence.","translation":"ഒന്ന്, ലോജിക് പൂർണ്ണമായും ഗണിതപരമായ ശ്രേണിയിലേക്ക് മാറ്റുന്നതിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Certain logical statements can be converted directly into a series of arithmetic operations.","translation":"ചില ലോജിക്കൽ സ്റ്റേറ്റ്‌മെന്റുകൾ, ഗണിത പ്രവർത്തനങ്ങളുടെ ഒരു പരമ്പരയിലേക്ക് നേരിട്ട് മാറ്റാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Consider the following code: mov eax, [ebp - 10] and eax, 0x00001000 neg eax sbb eax, eax neg eax ret","translation":"താഴെക്കൊടുത്തിരിക്കുന്ന കോഡ് ശ്രദ്ധിക്കുക: mov eax, [ebp - 10] and eax, 0x00001000 neg eax sbb eax, eax neg eax ret","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The code starts out with a simple logical AND of a local variable.","translation":"കോഡ് ഒരു പ്രാദേശിക വേരിയബിളിൻ്റെ ലളിതമായ ലോജിക്കൽ AND ഉപയോഗിച്ച് ആരംഭിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"You should go over this sample and make sure you understand how it works.","translation":"ഈ ഉദാഹരണം നിങ്ങൾ നന്നായി മനസ്സിലാക്കുകയും, ഇത് എങ്ങനെ പ്രവർത്തിക്കുമെന്നും ഉറപ്പാക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"NEG is a simple negation instruction, which reverses the sign of the operand.","translation":"NEG എന്നത് ഒരു ലളിതമായ നെഗേഷൻ നിർദ്ദേശമാണ്, ഇത് ഓപ്പറാൻ്റിൻ്റെ ചിഹ്നം മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The interesting part of this sequence is the SBB instruction.","translation":"ഈ ശ്രേണിയിലെ രസകരമായ ഭാഗം SBB നിർദ്ദേശമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"SBB is a subtraction with borrow instruction.","translation":"SBB എന്നത് കടംകൊണ്ടുള്ള കുറയ്ക്കൽ നിർദ്ദേശമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If CF == 1, EAX will become –1.","translation":"CF == 1 ആണെങ്കിൽ, EAX -1 ആകും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"If CF == 0, EAX will become zero.","translation":"CF == 0 ആണെങ്കിൽ, EAX പൂജ്യമാകും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"It appears that some compilers like to use this additional functionality provided by NEG.","translation":"NEG നൽകുന്ന ഈ അധിക പ്രവർത്തനം ചില കംപൈലറുകൾ ഉപയോഗിക്കാൻ സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Let’s quickly go over each step in this sequence.","translation":"ഈ ശ്രേണിയിലെ ഓരോ ഘട്ടവും നമുക്ക് വേഗത്തിൽ പരിശോധിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Use NEG to check whether the source operand is zero or nonzero.","translation":"സോഴ്സ് ഓപ്പറാൻഡ് പൂജ്യമാണോ അതോ പൂജ്യമല്ലാത്തതാണോ എന്ന് പരിശോധിക്കാൻ NEG ഉപയോഗിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The result is stored in CF.","translation":"ഫലം CF-ൽ സംഭരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Use SBB to transfer the result from CF back to a usable register.","translation":"CF-ൽ നിന്നുള്ള ഫലം, ഉപയോഗിക്കാവുന്ന ഒരു രജിസ്റ്ററിലേക്ക് മാറ്റാൻ SBB ഉപയോഗിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Essentially, what this sequence does is check for a particular bit in EAX.","translation":"ഈ ശ്രേണി EAX-ൽ ഒരു പ്രത്യേക ബിറ്റ് പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The program uses global variables as a sort of data root.","translation":"ഒരുതരം ഡാറ്റാ റൂട്ട് ആയി ഗ്ലോബൽ വേരിയബിളുകൾ പ്രോഗ്രാം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reversers must understand its data to truly understand a program.","translation":"ഒരു പ്രോഗ്രാം ശരിക്കും മനസ്സിലാക്കാൻ, റിവേഴ്സറുകൾ അതിന്റെ ഡാറ്റ മനസ്സിലാക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Local variables are used for storing any kind of immediate values.","translation":"ഏത് തരത്തിലുള്ള ഉടനടി മൂല്യങ്ങളും സംഭരിക്കുന്നതിന് ലോക്കൽ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The stack is organized into virtual 'layers' by each procedure.","translation":"ഓരോ നടപടിക്രമവും വെർച്വൽ 'പാളികളായി' അടുക്കിയിരിക്കുന്നത് സ്റ്റാക്കാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The ENTER and LEAVE instructions are built-in tools.","translation":"ENTER, LEAVE എന്നീ നിർദ്ദേശങ്ങൾ ബിൽറ്റ്-ഇൻ ടൂളുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"A calling convention defines how functions are called.","translation":"ഒരു കോളിംഗ് കൺവെൻഷൻ, ഫംഗ്ഷനുകൾ എങ്ങനെ വിളിക്കപ്പെടുന്നു എന്ന് നിർവചിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The cdecl calling convention is the standard C and C++ calling convention.","translation":"cdecl കോളിംഗ് കൺവെൻഷൻ, C, C++ എന്നിവയുടെ സാധാരണ കോളിംഗ് കൺവെൻഷനാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"fastcall uses registers for passing the first two parameters.","translation":"ആദ്യത്തെ രണ്ട് പാരാമീറ്ററുകൾ കൈമാറാൻ fastcall രജിസ്റ്ററുകൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"stdcall is very common in Windows.","translation":"വിൻഡോസിൽ stdcall വളരെ സാധാരണമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Global variables typically reside in fixed addresses.","translation":"ഗ്ലോബൽ വേരിയബിളുകൾ സാധാരണയായി നിശ്ചിത വിലാസങ്ങളിൽ കാണപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Compilers have two primary options for managing local variables.","translation":"ലോക്കൽ വേരിയബിളുകൾ കൈകാര്യം ചെയ്യാൻ കംപൈലറുകൾക്ക് രണ്ട് പ്രധാന ഓപ്ഷനുകളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The specific data type of the variable is not known from this instruction.","translation":"ഈ നിർദ്ദേശത്തിൽ നിന്ന് വേരിയബിളിന്റെ നിർദ്ദിഷ്ട ഡാറ്റാ തരം അജ്ഞാതമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Mapping and naming the local variables is a critical step.","translation":"ലോക്കൽ വേരിയബിളുകൾ മാപ്പ് ചെയ്യുകയും പേര് നൽകുകയും ചെയ്യുന്നത് ഒരു നിർണായക ഘട്ടമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"When developers need to pass parameters that can be modified.","translation":"ഡെവലപ്പർമാർക്ക്, പരിഷ്കരിക്കാൻ കഴിയുന്ന പാരാമീറ്ററുകൾ കൈമാറേണ്ടിവരുമ്പോൾ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Registers are always the most efficient way to store immediate values.","translation":"ഉടനടി മൂല്യങ്ങൾ സംഭരിക്കുന്നതിനുള്ള ഏറ്റവും കാര്യക്ഷമമായ മാർഗ്ഗമാണ് രജിസ്റ്ററുകൾ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The volatile keyword tells the compiler that other software might need to asynchronously read and write.","translation":"മറ്റ് സോഫ്റ്റ്‌വെയറുകൾക്ക് അസമന്വിതമായി വായിക്കാനും എഴുതാനും കഴിയുമെന്ന് volatile കീവേഡ് കംപൈലറോട് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Imported variables are usually named.","translation":"ഇറക്കുമതി ചെയ്ത വേരിയബിളുകൾ സാധാരണയായി പേരുള്ളവയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Constants are defined using #define directive.","translation":"#define നിർദ്ദേശം ഉപയോഗിച്ചാണ് സ്ഥിരമായവ നിർവചിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"This greatly improves readability for reversers.","translation":"ഇത് റിവേഴ്സറുകൾക്ക് വായനാക്ഷമത വളരെയധികം മെച്ചപ്പെടുത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The enforcement of the const keyword will be done at compile time.","translation":"const കീവേഡിന്റെ നടപ്പാക്കൽ കംപൈൽ സമയത്ത് ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Addition and Subtraction Integers are generally added and subtracted using the ADD and SUB instructions.","translation":"കൂട്ടുകയും കുറയ്ക്കുകയും ചെയ്യുന്നത് സാധാരണയായി ADD, SUB എന്നീ നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ചാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The specific combination of operands depends on the compiler.","translation":"ഓപ്പറാൻഡുകളുടെ(operands) നിർദ്ദിഷ്ട സംയോജനം കംപൈലറിനെ ആശ്രയിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Adding or subtracting an immediate operand usually reflects a constant that was hard-coded into the source code.","translation":"ഒരു തൽക്ഷണ ഓപ്പറാൻഡ് കൂട്ടുകയോ കുറയ്ക്കുകയോ ചെയ്യുന്നത് സാധാരണയായി സോഴ്സ് കോഡിൽ ഹാർഡ്-കോഡ് ചെയ്ത ഒരു സ്ഥിരതയെ പ്രതിഫലിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Note that both instructions store the result in the left-hand operand.","translation":"രണ്ട് നിർദ്ദേശങ്ങളും ഫലം ഇടത് കൈയ്യിലെ ഓപ്പറാൻഡിൽ സംഭരിക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Subtraction and addition are very simple operations that are performed very efficiently in modern IA-32 processors.","translation":" modern IA-32 പ്രോസസ്സറുകളിൽ വളരെ കാര്യക്ഷമമായി ചെയ്യുന്ന വളരെ ലളിതമായ പ്രവർത്തനങ്ങളാണ് കുറയ്ക്കലും കൂട്ടലും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"On older implementations of IA-32 the LEA instruction was considered to be faster than ADD and SUB.","translation":"പഴയ IA-32 നടപ്പാക്കലുകളിൽ, LEA നിർദ്ദേശം ADD, SUB എന്നിവയേക്കാൾ വേഗതയുള്ളതായി കണക്കാക്കപ്പെട്ടിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Here is how the LEA instruction can be used to perform an arithmetic operation.","translation":"ഒരു ഗണിതശാസ്ത്രപരമായ പ്രവർത്തനം നടപ്പിലാക്കാൻ LEA നിർദ്ദേശം എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"LEA never performs any actual memory accesses.","translation":"LEA ഒരിക്കലും മെമ്മറിയിലേക്ക് പ്രവേശനം (access) നടത്താറില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Starting with Pentium 4 the situation has reversed and most compilers will use ADD and SUB when generating code.","translation":"Pentium 4-ൽ ആരംഭിച്ച് സ്ഥിതിഗതികൾ വിപരീതമായി, കോഡ് ഉണ്ടാക്കുമ്പോൾ മിക്ക കംപൈലറുകളും ADD, SUB എന്നിവ ഉപയോഗിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Multiplication and division are both considered fairly complex operations in computers.","translation":"ഗുണനവും ഹരണവും കമ്പ്യൂട്ടറുകളിൽ സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങളായി കണക്കാക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The IA-32 processors provide instructions for several different kinds of multiplication and division, but they are both relatively slow.","translation":"വിവിധതരം ഗുണനത്തിനും ഹരണത്തിനും IA-32 പ്രോസസ്സറുകൾ നിർദ്ദേശങ്ങൾ നൽകുന്നു, എന്നാൽ രണ്ടും താരതമ്യേന കുറഞ്ഞ വേഗതയുള്ളവയാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Dividing or multiplying a number by powers of 2 is a very natural operation for a computer.","translation":"ഒരു സംഖ്യയെ 2-ന്റെ കൃത്യങ്കങ്ങൾ (powers) ഉപയോഗിച്ച് ഗുണിക്കുകയോ ഹരിക്കുകയോ ചെയ്യുന്നത് കമ്പ്യൂട്ടറിന് വളരെ സ്വാഭാവികമായ ഒരു പ്രവർത്തനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The general strategy is to try and bring the divisor or multiplier as close as possible to a convenient number.","translation":"വിഭജകത്തെയും ഗുണകത്തെയും സൗകര്യപ്രദമായ ഒരു സംഖ്യയോട് അടുപ്പിച്ചു കൊണ്ടുവരിക എന്നതാണ് പൊതുവായ തന്ത്രം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For IA-32 processors, the equivalent of shifting zeros around is to perform binary shifts using the SHL and SHR instructions.","translation":"IA-32 പ്രോസസ്സറുകൾക്ക്, പൂജ്യങ്ങൾ നീക്കുന്നതിന് തുല്യമായത് SHL, SHR നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് ബൈനറി ഷിഫ്റ്റുകൾ നടത്തുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"When you are multiplying a variable by another variable, the MUL/IMUL instruction is generally the most efficient tool.","translation":"ഒരു വേരിയബിളിനെ മറ്റൊരു വേരിയബിൾ ഉപയോഗിച്ച് ഗുണിക്കുമ്പോൾ, MUL/IMUL നിർദ്ദേശമാണ് സാധാരണയായി ഏറ്റവും കാര്യക്ഷമമായ ഉപകരണം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Still, most compilers will completely avoid using these instructions when the multiplier is a constant.","translation":"എങ്കിലും, ഗുണിതം ഒരു സ്ഥിരസംഖ്യയാണെങ്കിൽ, മിക്ക കംപൈലറുകളും ഈ നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നത് പൂർണ്ണമായും ഒഴിവാക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For example, multiplying a variable by 3 is usually implemented by shifting the number by 1 bit to the left and then adding the original value to the result.","translation":"ഉദാഹരണത്തിന്, ഒരു വേരിയബിളിനെ 3 കൊണ്ട് ഗുണിക്കുന്നത് സാധാരണയായി സംഖ്യയെ 1 ബിറ്റ് ഇടത്തേക്ക് മാറ്റുകയും തുടർന്ന് യഥാർത്ഥ മൂല്യം ഫലത്തിലേക്ക് ചേർക്കുകയും ചെയ്യുന്നതിലൂടെ നടപ്പിലാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In more complicated cases, compilers use a combination of LEA and ADD.","translation":"കൂടുതൽ സങ്കീർണ്ണമായ സന്ദർഭങ്ങളിൽ, കംപൈലറുകൾ LEA, ADD എന്നിവയുടെ ഒരു സംയോജനം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"For computers, division is the most complex operation in integer arithmetic.","translation":"കമ്പ്യൂട്ടറുകളെ സംബന്ധിച്ചിടത്തോളം, ഹരണമാണ് പൂർണ്ണസംഖ്യാ ഗണിതത്തിലെ ഏറ്റവും സങ്കീർണ്ണമായ പ്രവർത്തനം.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The compiler can employ some highly creative techniques for efficiently implementing division, depending on the divisor.","translation":"ഹരണത്തെ കാര്യക്ഷമമായി നടപ്പിലാക്കാൻ, വിഭജകനെ ആശ്രയിച്ച്, ചില ഉയർന്ന സർഗ്ഗാത്മകമായ സാങ്കേതിക വിദ്യകൾ കംപൈലറിന് ഉപയോഗിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Each constructor initializes the virtual function table to its own table.","translation":"ഓരോ കൺസ്ട്രക്റ്ററും വെർച്വൽ ഫംഗ്ഷൻ ടേബിൾ സ്വന്തം ടേബിളിലേക്ക് ഇനിഷ്യലൈസ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is because the constructors can’t know which particular type of object was instantiated—the inherited class or the base class.","translation":"കാരണം, ഏത് തരത്തിലുള്ള ഒബ്ജക്റ്റാണ് ഇൻസ്റ്റൻ്റേറ്റ് ചെയ്തതെന്ന് കൺസ്ട്രക്റ്ററുകൾക്ക് അറിയില്ല - ഇൻഹെറിറ്റഡ് ക്ലാസ്സോ ബേസ് ക്ലാസ്സോ.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Notice how the constructor actually calls the base class’s constructor.","translation":"കൺസ്ട്രക്റ്റർ എങ്ങനെയാണ് ബേസ് ക്ലാസിൻ്റെ കൺസ്ട്രക്റ്ററെ വിളിക്കുന്നതെന്ന് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This is how object initialization takes place in C++.","translation":"ഇങ്ങനെയാണ് C++-ൽ ഒബ്ജക്റ്റ് ഇനിഷ്യലൈസേഷൻ നടക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"An object is initialized and the constructor for its specific type is called.","translation":"ഒരു ഒബ്ജക്റ്റ് ഇനിഷ്യലൈസ് ചെയ്യുകയും അതിൻ്റെ നിർദ്ദിഷ്ട തരത്തിലുള്ള കൺസ്ട്രക്റ്റർ വിളിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If the object is inherited, the compiler adds calls to the ancestor’s constructor before the beginning of the descendant’s actual constructor code.","translation":"ഒബ്ജക്റ്റ് ഇൻഹെറിറ്റ് ചെയ്താൽ, ഡെസൻ്റൻ്റിൻ്റെ യഥാർത്ഥ കൺസ്ട്രക്റ്റർ കോഡിൻ്റെ തുടക്കത്തിനുമുമ്പ്, പൂർവ്വികരുടെ കൺസ്ട്രക്റ്ററിലേക്ക് കോൾ ചേർക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The same process takes place in each ancestor’s constructor until the base class is reached.","translation":"ബേസ് ക്ലാസിൽ എത്തുന്നതുവരെ ഓരോ പൂർവ്വികരുടെയും കൺസ്ട്രക്റ്ററിൽ ഇതേ പ്രക്രിയ നടക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Notice how the base class sets the virtual function pointer to its own copy only to be replaced by the inherited class’s constructor as soon as this function returns.","translation":"ഈ ഫംഗ്ഷൻ തിരികെ വരുമ്പോൾ തന്നെ, വെർച്വൽ ഫംഗ്ഷൻ പോയിൻ്റർ സ്വന്തം കോപ്പിയിലേക്ക് ബേസ് ക്ലാസ് എങ്ങനെയാണ് സെറ്റ് ചെയ്യുന്നതെന്നും, ഇൻഹെറിറ്റഡ് ക്ലാസിൻ്റെ കൺസ്ട്രക്റ്റർ വഴി ഇത് എങ്ങനെ മാറ്റിസ്ഥാപിക്കുമെന്നും ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Also note that this function doesn’t call any other constructors since it is the base class.","translation":"ബേസ് ക്ലാസ് ആയതിനാൽ ഈ ഫംഗ്ഷൻ മറ്റ് കൺസ്ട്രക്റ്ററുകളെ വിളിക്കുന്നില്ല എന്നതും ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"If you were to follow a chain of constructors where each call its parent’s constructor, you would know you reached the base class at this point because this constructor doesn’t call anyone else, it just initializes the virtual function table and returns.","translation":"ഓരോ കൺസ്ട്രക്റ്ററും അതിൻ്റെ മാതാപിതാക്കളുടെ കൺസ്ട്രക്റ്ററെ വിളിക്കുന്ന ഒരു ശൃംഖല പിന്തുടരുകയാണെങ്കിൽ, ഈ കൺസ്ട്രക്റ്റർ മറ്റാരെയും വിളിക്കാത്തതുകൊണ്ട്, നിങ്ങൾ ഈ ഘട്ടത്തിൽ ബേസ് ക്ലാസ്സിൽ എത്തിച്ചേരുമെന്ന് അറിയുക, ഇത് വെർച്വൽ ഫംഗ്ഷൻ ടേബിൾ ഇനിഷ്യലൈസ് ചെയ്യുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The program crashed due to a memory error.","translation":"മെമ്മറി error കാരണം പ്രോഗ്രാം ക്രാഷ് ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Debugging is a crucial part of software development.","translation":"ഡീബഗ്ഗിംഗ് സോഫ്റ്റ്‌വെയർ വികസനത്തിന്റെ ഒരു പ്രധാന ഭാഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The software was reverse engineered to understand its functionality.","translation":"പ്രവർത്തനങ്ങൾ മനസ്സിലാക്കാൻ സോഫ്റ്റ്‌വെയർ റിവേഴ്സ് എഞ്ചിനീയറിംഗ് നടത്തി.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This code snippet demonstrates a common programming pattern.","translation":"ഈ കോഡ് ഭാഗം ഒരു സാധാരണ പ്രോഗ്രാമിംഗ് രീതി കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The algorithm's efficiency was analyzed.","translation":"അൽഗോരിതത്തിന്റെ കാര്യക്ഷമത വിശകലനം ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The application uses several third-party libraries.","translation":"ആപ്ലിക്കേഷൻ നിരവധി മൂന്നാം കക്ഷി ലൈബ്രറികൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Security vulnerabilities were identified during the audit.","translation":"ഓഡിറ്റിംഗിൽ സുരക്ഷാ പ്രശ്നങ്ങൾ കണ്ടെത്തി.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The system's architecture is complex.","translation":"സിസ്റ്റത്തിന്റെ ആർക്കിടെക്ചർ സങ്കീർണ്ണമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The software update fixed a critical bug.","translation":"സോഫ്റ്റ്‌വെയർ അപ്‌ഡേറ്റ് ഒരു പ്രധാന പ്രശ്നം പരിഹരിച്ചു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Understanding the code's control flow is essential for debugging.","translation":"ഡീബഗ്ഗിംഗിനായി കോഡിന്റെ കൺട്രോൾ ഫ്ലോ മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Code analysis is a crucial part of reverse engineering.","translation":"കോഡ് വിശകലനം റിവേഴ്സ് എഞ്ചിനിയറിംഗിന്റെ ഒരു പ്രധാന ഭാഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The document discusses 110 local variables.","translation":"ഈ ഡോക്യുമെന്റിൽ 110 പ്രാദേശിക വേരിയബിളുകളെക്കുറിച്ച് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Logical operators are essential for program control.","translation":"പ്രോഗ്രാം നിയന്ത്രണത്തിന് ലോജിക്കൽ ഓപ്പറേറ്റർമാർ അത്യാവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Break conditions in loops are important to avoid infinite loops.","translation":"അനന്തമായ ലൂപ്പുകൾ ഒഴിവാക്കാൻ ലൂപ്പുകളിലെ ബ്രേക്ക് അവസ്ഥകൾ പ്രധാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Malicious software can cause significant damage.","translation":"ദോഷകരമായ സോഫ്റ്റ്‌വെയറുകൾക്ക് കാര്യമായ നാശനഷ്ടം വരുത്താൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Backdoors allow unauthorized access to systems.","translation":"ബാക്ക്‌ഡോറുകൾക്ക് സിസ്റ്റങ്ങളിൽ അനധികൃത പ്രവേശനം അനുവദിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Viruses and worms are types of malware.","translation":"വൈറസുകളും, വിരകളും, ക്ഷുദ്ര സോഫ്റ്റ്‌വെയറുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Memory management is a critical aspect of software development.","translation":"മെമ്മറി മാനേജ്മെൻ്റ് സോഫ്റ്റ്‌വെയർ വികസനത്തിന്റെ ഒരു നിർണായക ഘടകമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Obfuscation techniques are used to make code harder to understand.","translation":"കോഡ് മനസ്സിലാക്കാൻ ബുദ്ധിമുട്ടാക്കാൻ ഒബ്‌ഫസ്‌ക്കേഷൻ ടെക്നിക്കുകൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The .NET platform provides a managed code environment.","translation":".NET പ്ലാറ്റ്‌ഫോം ഒരു നിയന്ത്രിത കോഡ് പരിസ്ഥിതി നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Reverse engineering can help understand how software works.","translation":"സോഫ്റ്റ്‌വെയർ എങ്ങനെ പ്രവർത്തിക്കുമെന്നു മനസ്സിലാക്കാൻ റിവേഴ്സ് എഞ്ചിനിയറിംഗ് സഹായിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Debugging tools are essential for finding and fixing errors.","translation":"തെറ്റുകൾ കണ്ടെത്താനും പരിഹരിക്കാനും ഡീബഗ്ഗിംഗ് ടൂളുകൾ അത്യാവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Understanding assembly language is key to reverse engineering.","translation":"അസംബ്ലി ഭാഷ മനസ്സിലാക്കുന്നത് റിവേഴ്സ് എഞ്ചിനിയറിംഗിന്റെ പ്രധാന കാര്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The article discusses various obfuscation methods.","translation":"ഈ ലേഖനത്തിൽ വിവിധ ഒബ്‌ഫസ്‌ക്കേഷൻ രീതികളെക്കുറിച്ച് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"Software piracy is a significant problem in the industry.","translation":"സോഫ്റ്റ്‌വെയർ പൈറസി വ്യവസായത്തിൽ ഒരു പ്രധാന പ്രശ്നമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Digital rights management (DRM) is used to protect content.","translation":"ഉള്ളടക്കം പരിരക്ഷിക്കാൻ ഡിജിറ്റൽ റൈറ്റ്സ് മാനേജ്മെൻ്റ് (DRM) ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The study analyzes the vulnerabilities of the system.","translation":"ഈ പഠനം സിസ്റ്റത്തിന്റെ ദൗർബല്യങ്ങൾ വിശകലനം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The use of encryption is a common security measure.","translation":"എൻക്രിപ്ഷൻ്റെ ഉപയോഗം ഒരു സാധാരണ സുരക്ഷാ നടപടിയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The debugger helps to trace the execution of the program.","translation":"പ്രോഗ്രാമിന്റെ എക്സിക്യൂഷൻ കണ്ടെത്താൻ ഡീബഗ്ഗർ സഹായിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"This document provides an overview of the software's architecture.","translation":"ഈ ഡോക്യുമെന്റ് സോഫ്റ്റ്‌വെയറിന്റെ ആർക്കിടെക്ചറിനെക്കുറിച്ചുള്ള ഒരു വിവരണം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Thread-Local Storage (TLS) is useful for programs that are heavily thread-dependent.","translation":"ത്രെഡ്-ലോക്കൽ സ്റ്റോറേജ് (ടിഎൽഎസ്) വളരെ ത്രെഡ്-ആശ്രിതത്വമുള്ള പ്രോഗ്രാമുകൾക്ക് ഉപയോഗപ്രദമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Using TLS instead of using regular global variables provides a highly efficient method for managing thread-specific data structures.","translation":"സ്ഥിരമായ ഗ്ലോബൽ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നതിനുപകരം TLS ഉപയോഗിക്കുന്നത്, ത്രെഡ്-നിർദ്ദിഷ്ട ഡാറ്റാ ഘടനകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള വളരെ കാര്യക്ഷമമായ രീതി നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"In Windows there are two primary techniques for implementing thread-local storage in a program.","translation":"വിൻഡോസിൽ ഒരു പ്രോഗ്രാമിൽ ത്രെഡ്-ലോക്കൽ സ്റ്റോറേജ് നടപ്പിലാക്കുന്നതിന് രണ്ട് പ്രധാന സാങ്കേതിക വിദ്യകളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"One is to allocate TLS storage using the TLS API.","translation":"ഒന്ന്, TLS API ഉപയോഗിച്ച് TLS സംഭരണം അനുവദിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"The TLS API includes several functions such as TlsAlloc, TlsGetValue, and TlsSetValue that provide programs with the ability to manage a small pool of thread-local 32-bit values.","translation":"TlsAlloc, TlsGetValue, TlsSetValue തുടങ്ങിയ നിരവധി ഫംഗ്ഷനുകൾ TLS API-യിൽ ഉൾപ്പെടുന്നു, ഇത് പ്രോഗ്രാമുകൾക്ക് ത്രെഡ്-ലോക്കൽ 32-ബിറ്റ് മൂല്യങ്ങളുടെ ഒരു ചെറിയ പൂൾ കൈകാര്യം ചെയ്യാനുള്ള കഴിവ് നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Another approach for implementing thread-local storage in Windows programs is based on a different approach that doesn’t involve any API calls.","translation":"വിൻഡോസ് പ്രോഗ്രാമുകളിൽ ത്രെഡ്-ലോക്കൽ സ്റ്റോറേജ് നടപ്പിലാക്കുന്നതിനുള്ള മറ്റൊരു സമീപനം API കോളുകളൊന്നും ഉൾപ്പെടാത്ത ഒരു വ്യത്യസ്ത രീതിയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"The idea is to define a global variable with the declspec(thread) attribute that places the variable in a special thread-local section of the image executable.","translation":"ചിത്രം എക്സിക്യൂട്ടബിളിന്റെ പ്രത്യേക ത്രെഡ്-ലോക്കൽ വിഭാഗത്തിൽ വേരിയബിൾ സ്ഥാപിക്കുന്ന declspec(thread) ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് ഒരു ഗ്ലോബൽ വേരിയബിൾ നിർവചിക്കുക എന്നതാണ് ആശയം.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"In such cases the variable can easily be identified while reversing as thread local because it will point to a different image section than the rest of the global variables in the executable.","translation":"അത്തരം സന്ദർഭങ്ങളിൽ, എക്സിക്യൂട്ടബിളിലെ മറ്റ് ഗ്ലോബൽ വേരിയബിളുകളേക്കാൾ വ്യത്യസ്തമായ ഒരു ഇമേജ് വിഭാഗത്തിലേക്ക് ഇത് ചൂണ്ടിക്കാണിക്കുന്നതിനാൽ, റിവേഴ്സ് ചെയ്യുമ്പോൾ വേരിയബിൾ ത്രെഡ് ലോക്കൽ ആയി എളുപ്പത്തിൽ തിരിച്ചറിയാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"If required, it is quite easy to check the attributes of the section containing the variable (using a PE-dumping tool such as DUMPBIN) and check whether it’s thread-local storage.","translation":"ആവശ്യമെങ്കിൽ, വേരിയബിൾ അടങ്ങിയിരിക്കുന്ന വിഭാഗത്തിന്റെ ആട്രിബ്യൂട്ടുകൾ (DUMPBIN പോലുള്ള ഒരു PE-ഡംപിംഗ് ടൂൾ ഉപയോഗിച്ച്) പരിശോധിക്കാനും ഇത് ത്രെഡ്-ലോക്കൽ സ്റ്റോറേജാണോ എന്ന് പരിശോധിക്കാനും വളരെ എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Note that the thread attribute is generally a Microsoft-specific compiler extension.","translation":"ത്രെഡ് ആട്രിബ്യൂട്ട് സാധാരണയായി ഒരു Microsoft-നിർദ്ദിഷ്ട കംപൈലർ എക്സ്റ്റൻഷനാണ് എന്നത് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"A data structure is any kind of data construct that is specifically laid out in memory to meet certain program needs.","translation":"ഒരു ഡാറ്റാ ഘടന എന്നത് ചില പ്രോഗ്രാം ആവശ്യങ്ങൾ നിറവേറ്റുന്നതിനായി മെമ്മറിയിൽ പ്രത്യേകം സ്ഥാപിച്ചിട്ടുള്ള ഏതെങ്കിലും തരത്തിലുള്ള ഡാറ്റാ ഘടനയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Identifying data structures in memory is not always easy because the philosophy and idea behind their organization are not always known.","translation":"മെമ്മറിയിലെ ഡാറ്റാ ഘടനകൾ തിരിച്ചറിയുന്നത് എപ്പോഴും എളുപ്പമാകണമെന്നില്ല, കാരണം അവയുടെ ഓർഗനൈസേഷന് പിന്നിലെ തത്വവും ആശയവും എല്ലായ്പ്പോഴും അറിയപ്പെടണമെന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The following sections discuss the most common layouts and how they are implemented in assembly language.","translation":"അസംബ്ലി ഭാഷയിൽ അവ എങ്ങനെ നടപ്പിലാക്കുന്നു എന്നതിനെക്കുറിച്ചും ഏറ്റവും സാധാരണമായ ലേഔട്ടുകളെക്കുറിച്ചും താഴെയുള്ള ഭാഗങ്ങളിൽ ചർച്ച ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"These include generic data structures, arrays, linked lists, and trees.","translation":"ഇവയിൽ സാധാരണ ഡാറ്റാ ഘടനകൾ, അറേകൾ, ലിങ്ക്ഡ് ലിസ്റ്റുകൾ, ട്രീകൾ എന്നിവ ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"}
{"en":"A generic data structure is any chunk of memory that represents a collection of fields of different data types, where each field resides at a constant distance from the beginning of the block.","translation":"ഒരു സാധാരണ ഡാറ്റാ ഘടന എന്നത് വ്യത്യസ്ത ഡാറ്റാ തരങ്ങളുടെ ഫീൽഡുകളുടെ ഒരു ശേഖരം പ്രതിനിധീകരിക്കുന്ന മെമ്മറിയുടെ ഏതെങ്കിലും ഭാഗമാണ്, അവിടെ ഓരോ ഫീൽഡും ബ്ലോക്കിന്റെ തുടക്കത്തിൽ നിന്ന് സ്ഥിരമായ ദൂരത്തിൽ സ്ഥിതിചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"This is a very broad definition that includes anything defined using the struct keyword in C and C++ or using the class keyword in C++.","translation":"C, C++ എന്നിവയിൽ struct കീവേഡ് ഉപയോഗിച്ചോ അല്ലെങ്കിൽ C++-ൽ class കീവേഡ് ഉപയോഗിച്ചോ നിർവചിച്ചിട്ടുള്ള എന്തിനെയും ഇത് ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"The important thing to remember about such structures is that they have a static arrangement that is defined at compile time, and they usually have a static size.","translation":"അത്തരം ഘടനകളെക്കുറിച്ച് ഓർക്കേണ്ട പ്രധാനപ്പെട്ട കാര്യം, അവയ്ക്ക് കംപൈൽ സമയത്ത് നിർവചിക്കപ്പെട്ടിട്ടുള്ള ഒരു സ്ഥിരമായ ക്രമീകരണമുണ്ട്, കൂടാതെ അവ സാധാരണയായി ഒരു സ്ഥിര വലുപ്പവും ഉണ്ടായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"It is possible to create a data structure where the last member is a variable-sized array and that generates code that dynamically allocates the structure in runtime based on its calculated size.","translation":"അവസാന അംഗം വേരിയബിൾ-സൈസ്ഡ് അറേ ആയിട്ടുള്ള ഒരു ഡാറ്റാ ഘടന ഉണ്ടാക്കാൻ കഴിയും, ഇത് കണക്കാക്കിയ വലുപ്പത്തെ അടിസ്ഥാനമാക്കി റൺടൈമിൽ ഘടനയെ ഡൈനാമിക് ആയി അനുവദിക്കുന്ന കോഡ് ഉണ്ടാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"}
{"en":"Such structures rarely reside on the stack because normally the stack only contains fixed-size elements.","translation":"അത്തരം ഘടനകൾ വളരെ അപൂർവമായി മാത്രമേ സ്റ്റാക്കിൽ കാണപ്പെടാറുള്ളൂ, കാരണം സാധാരണയായി സ്റ്റാക്കിൽ സ്ഥിര വലുപ്പത്തിലുള്ള ഘടകങ്ങൾ മാത്രമേ ഉണ്ടാകൂ.","target_lang":"ml","domain":"technical","complexity":"moderate"}
{"en":"Data structures are usually aligned to the processor’s native word-size boundaries.","translation":"ഡാറ്റാ ഘടനകൾ സാധാരണയായി പ്രോസസ്സറിന്റെ നേറ്റീവ് വേർഡ്-സൈസ് അതിർത്തികളിലേക്ക് അലൈൻ ചെയ്യാറുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"}