---

c compiler (subgroup of compiler) → HasA → option	0.79
compiler → CapableOf → generate code	0.74
compiler → IsA → program	0.72
compiler → CapableOf → generate warning	0.69
c compiler (subgroup of compiler) → CapableOf → insert back door	0.68
c compiler (subgroup of compiler) → ReceivesAction → released in april	0.68
java compiler (subgroup of compiler) → ReceivesAction → installed	0.68
compiler → CapableOf → infer the type	0.67
compiler → CapableOf → perform optimization	0.66
compiler → HasProperty → smart	0.64
compiler → CapableOf → optimize the code	0.61
compiler → CapableOf → compile code	0.60
compiler → HasProperty → correct	0.60
compiler → CapableOf → call the function	0.59
cross compiler (subgroup of compiler) → CapableOf → make compiling openocd	0.59
compiler → ReceivesAction → installed	0.58
compiler → CapableOf → transform source code	0.57
compiler → CapableOf → give error	0.55
compiler → CapableOf → create a default constructor	0.55
compiler → CapableOf → emit code	0.55
compiler → HasProperty → sure	0.54
compiler → CapableOf → unroll loop	0.53
compiler → CapableOf → translate source code	0.53
compiler → CapableOf → inline the function	0.52
compiler → CapableOf → generate different code	0.51
compiler → CapableOf → generate assembly code	0.50
compiler → HasProperty → good	0.50
compiler → ReceivesAction → bypassed	0.50
compiler → CapableOf → produce executable	0.50
compiler → HasA → option	0.48
compiler → CapableOf → throw error	0.48
compiler → CapableOf → translate program	0.48
compiler → CapableOf → support the common language runtime	0.48
compiler → CapableOf → adhere to the standard	0.48
compiler → CapableOf → support c++11	0.48
compiler → HasA → bug	0.48
compiler → HasProperty → efficient	0.47
compiler → CapableOf → generate machine code	0.46
compiler → CapableOf → generate object code	0.46
compiler → ReceivesAction → written in the language	0.45
compiler → CapableOf → optimize	0.45
compiler → CapableOf → generate error	0.45
compiler → CapableOf → report error	0.44
compiler → CapableOf → produce an object file	0.44
compiler → CapableOf → read the value	0.44
compiler → CapableOf → flag error	0.44
compiler → ReceivesAction → run	0.44
compiler → CapableOf → make assumption	0.43
compiler → CapableOf → target processor	0.43
compiler → CapableOf → generate more efficient code	0.43
compiler → HasA → binary form	0.42
compiler → CapableOf → generate call	0.42
compiler → ReceivesAction → invoked	0.41
compiler → CapableOf → convert the source code	0.41
compiler → CapableOf → do right thing	0.41
compiler → HasProperty → conservative	0.41
compiler → CapableOf → make adjustment	0.41
compiler → CapableOf → attempt to decompose operator	0.41
compiler → HasA → switch	0.41
compiler → CapableOf → transform the code	0.41
compiler → CapableOf → read file	0.41
compiler → HasProperty → dumb	0.41
compiler → HasProperty → slow	0.40
compiler → CapableOf → generate an error message	0.40
compiler → CapableOf → execute the code	0.40
compiler → CapableOf → convert the program	0.40
compiler → CapableOf → do the rest	0.40
compiler → HasProperty → smarter	0.39
compiler → CapableOf → allocate memory	0.39
compiler → CapableOf → perform type checking	0.39
compiler → CapableOf → compile file	0.39
compiler → ReceivesAction → written in java	0.39
compiler → CapableOf → add code	0.39
compiler → CapableOf → generate exit sequences	0.39
compiler → HasProperty → free	0.39
compiler → HasProperty → wrong	0.38
compiler → IsA → set of programs	0.38
compiler → CapableOf → analyze the code	0.38
compiler → CapableOf → generate class	0.38
compiler → HasProperty → complete	0.38
compiler → CapableOf → detect the situation	0.38
compiler → CapableOf → compile itself	0.38
compiler → CapableOf → compile source code	0.38
compiler → CapableOf → compile call	0.38
compiler → CapableOf → compile c++	0.38
compiler → CapableOf → look for library	0.38
compiler → CapableOf → reorder store	0.38
compiler → CapableOf → use itrs	0.38
compiler → CapableOf → generate optimal code	0.38
compiler → CapableOf → generate function entry	0.37
compiler → CapableOf → read the source file	0.37
compiler → CapableOf → fix bug	0.36
compiler → CapableOf → create type	0.36
compiler → ReceivesAction → satisfied	0.36
compiler → CapableOf → generate same code	0.36
compiler → CapableOf → tried to include other canadian websites	0.36
compiler → CapableOf → generate seth/add3 instructions	0.36
compiler → CapableOf → determine the most appropriate type	0.36
compiler → CapableOf → use llvm	0.36
compiler → CapableOf → use register	0.36
compiler → ReceivesAction → inlined	0.36
compiler → CapableOf → use assembler	0.36
compiler → CapableOf → do better job	0.36
compiler → CapableOf → do the work	0.36
compiler → CapableOf → become more sophisticated	0.36
compiler → ReceivesAction → changed	0.35
compiler → CapableOf → generate better code	0.35
compiler → HasProperty → happy	0.35
compiler → CapableOf → compile byte code	0.35
compiler → CapableOf → call the module	0.35
compiler → ReceivesAction → described in more detail	0.35
compiler → CapableOf → check argument	0.35
compiler → ReceivesAction → implemented	0.35
compiler → CapableOf → vectorize the code	0.35
compiler → CapableOf → generate file	0.35
compiler → CapableOf → elide copy	0.35
compiler → CapableOf → look for file	0.35
compiler → CapableOf → allocate variable	0.35
compiler → HasProperty → important	0.35
compiler → HasProperty → more aggressive	0.35
compiler → CapableOf → provide way	0.35
compiler → ReceivesAction → tested	0.35
compiler → AtLocation → /usr/bin	0.35
compiler → HasProperty → fast	0.34
compiler → CapableOf → check the condition	0.34
compiler → HasProperty → true	0.34
compiler → CapableOf → take program	0.34
compiler → CapableOf → reorder instruction	0.34
compiler → CapableOf → do a lot of work	0.34
compiler → CapableOf → know type	0.34
compiler → CapableOf → use type information	0.34
compiler → CapableOf → raise error	0.34
compiler → CapableOf → interpret the code	0.33
compiler → CapableOf → go to resolve function	0.33
compiler → CapableOf → generate debug information	0.33
compiler → CapableOf → know at compile-time	0.33
compiler → CapableOf → keep track	0.33
compiler → CapableOf → generate setter methods	0.33
compiler → CapableOf → try to reduce code size	0.33
compiler → ReceivesAction → shown in fig	0.33
compiler → CapableOf → produce program	0.33
compiler → HasA → enough information	0.33
compiler → CapableOf → take source code	0.33
compiler → CapableOf → encounter function	0.33
compiler → ReceivesAction → used to generate code	0.33
compiler → CapableOf → replace the function call	0.33
compiler → CapableOf → create the directory build/gen/bar	0.33
compiler → CapableOf → see call	0.33
compiler → CapableOf → check for error	0.33
compiler → ReceivesAction → updated	0.31
compiler → CapableOf → translate entire program	0.31
compiler → CapableOf → infer the type of the variable	0.31
compiler → CapableOf → optimize for size	0.31
compiler → CapableOf → produce compiled modules	0.31
compiler → ReceivesAction → allowed to try to replace register number	0.31
compiler → CapableOf → assign address	0.31
compiler → CapableOf → make use of it	0.31
compiler → CapableOf → generate c code	0.31
compiler → ReceivesAction → improved	0.31
compiler → CapableOf → try to reduce execution time	0.31
compiler → CapableOf → create table	0.31
compiler → CapableOf → figure	0.31
compiler → CapableOf → use type inference	0.31
compiler → ReceivesAction → likely to perform many	0.31
compiler → CapableOf → become more complex	0.31
compiler → CapableOf → generate parallel code	0.31
compiler → CapableOf → suppress warning	0.31
compiler → ReceivesAction → adapted to receive a business logic component	0.31
compiler → CapableOf → generate appropriate code	0.31
compiler → CapableOf → evaluate the expression	0.31
compiler → CapableOf → support digital devices	0.31
compiler → CapableOf → use the cuda toolkit	0.31
compiler → ReceivesAction → written in c#	0.31
compiler → CapableOf → do implicit move	0.31
compiler → CapableOf → perform operation	0.30
compiler → CapableOf → throw exception	0.30
compiler → CapableOf → insert call	0.30
compiler → CapableOf → tried to include local area	0.30
compiler → CapableOf → tried to include durham region	0.30
compiler → CapableOf → tried to include exclusively	0.30
compiler → CapableOf → resolve the call	0.30
compiler → CapableOf → check the format string	0.30
compiler → CapableOf → generate getter	0.30
compiler → CapableOf → delete the memset function call	0.30
compiler → CapableOf → instantiate template	0.30
compiler → CapableOf → run time	0.30
compiler → CapableOf → generate method	0.30
compiler → CapableOf → encounter a varargs method	0.30
compiler → CapableOf → translate the varargs	0.30
compiler → CapableOf → make decision	0.30
compiler → CapableOf → know current working directory	0.30
compiler → HasProperty → new	0.30
compiler → ReceivesAction → executed on the processor	0.30
compiler → CapableOf → remove unused code	0.30
compiler → CapableOf → generate good code	0.29
compiler → CapableOf → generate optimized code	0.28
compiler → HasProperty → strict	0.28
compiler → CapableOf → vectorize loops	0.28
compiler → CapableOf → generate incorrect code	0.28
bug → AtLocation → the compiler	0.28
compiler → CapableOf → determine at compile time	0.28
compiler → CapableOf → generate an expression tree	0.28
compiler → CapableOf → eliminate the need	0.28
compiler → HasProperty → successful	0.28
compiler → CapableOf → generate load	0.28
compiler → CapableOf → initialize the virtual function table	0.28
compiler → CapableOf → create two object files	0.28
compiler → CapableOf → declare variable	0.28
compiler → CapableOf → substitute proper function code	0.28
compiler → CapableOf → target the jvm	0.28
compiler → CapableOf → perform static analysis	0.28
compiler → IsA → special program	0.28
compiler → ReceivesAction → written by grace hopper	0.28
compiler → CapableOf → treat variable	0.28
compiler → CapableOf → do static type checking	0.28
compiler → CapableOf → generate slower seth/add3/jl instruction sequence	0.28
compiler → CapableOf → use heuristic	0.28
compiler → ReceivesAction → provided by microsoft	0.28
compiler → CapableOf → compile entire class	0.28
compiler → CapableOf → search for the particular header file	0.28
compiler → ReceivesAction → removed	0.28
compiler → CapableOf → copy the value	0.28
compiler → HasProperty → deterministic	0.28
compiler → CapableOf → change floating-point division computations	0.28
compiler → CapableOf → promote the type	0.28
compiler → CapableOf → read program	0.28
compiler → HasProperty → stable	0.28
compiler → CapableOf → generate a runtime test	0.28
compiler → CapableOf → generate unchecked warning	0.28
compiler → CapableOf → remove call	0.28
compiler → CapableOf → default unqualified char types	0.28
compiler → CapableOf → optimize the variable	0.28
compiler → CapableOf → implement following three-operand pseudo	0.28
compiler → ReceivesAction → re	0.28
compiler → CapableOf → use other method	0.28
compiler → CapableOf → provide default generic implementation	0.28
compiler → ReceivesAction → added to cygwin	0.28
compiler → CapableOf → perform implicit conversion	0.28
compiler → CapableOf → convert operand	0.28
compiler → CapableOf → place the library name	0.28
compiler → CapableOf → report an ambiguity error	0.27
compiler → CapableOf → display error	0.27
compiler → CapableOf → do good job	0.27
compiler → CapableOf → get fatal signal	0.25
compiler → CapableOf → refuse to compile the code	0.25
compiler → CapableOf → raise syntaxerror	0.25
compiler → ReceivesAction → designed to be smart	0.25
compiler → HasProperty → simple	0.25
compiler → HasProperty → big	0.25
compiler → CapableOf → choose inline definition	0.25
compiler → CapableOf → align datum	0.25
compiler → CapableOf → generate output	0.25
compiler → CapableOf → generate a default no-arg constructor	0.25
compiler → CapableOf → convert high-level language	0.25
compiler → CapableOf → do their job	0.25
compiler → ReceivesAction → coupled to the processing unit	0.25
compiler → CapableOf → produce standalone executables	0.25
compiler → CapableOf → generate following adjustor	0.25
compiler → CapableOf → generate arm code	0.25
compiler → CapableOf → try to interpret the file	0.25
compiler → CapableOf → create myclass.o	0.25
compiler → CapableOf → create mymain.o	0.25
compiler → ReceivesAction → bootstrapped	0.25
compiler → ReceivesAction → written in nekoml	0.25
compiler → CapableOf → construct actual object	0.25
compiler → CapableOf → call the linker	0.25
compiler → CapableOf → optimize for speed	0.25
compiler → CapableOf → recognize case	0.25
compiler → CapableOf → give a frame pointer	0.25
compiler → CapableOf → use the specialization	0.25
compiler → CapableOf → handle the conversion	0.25
compiler → CapableOf → determine a plug-in	0.25
compiler → CapableOf → call correct function	0.25
compiler → CapableOf → create .class files	0.25
compiler → CapableOf → look at entire piece of source code	0.25
compiler → CapableOf → conform to iso standard c.	0.25
compiler → CapableOf → generate efficient object code	0.25
compiler → ReceivesAction → trusted	0.25
compiler → ReceivesAction → linked	0.25
compiler → CapableOf → generate a state machine	0.25
compiler → CapableOf → use pattern	0.25
compiler → CapableOf → infer the return type	0.25
compiler → CapableOf → provide global pointer	0.25
compiler → CapableOf → display message	0.25
compiler → CapableOf → build the kernel	0.25
compiler → CapableOf → call the method	0.25
compiler → CapableOf → replace type	0.25
compiler → CapableOf → issue a deprecation warning	0.25
compiler → CapableOf → find declaration	0.25
compiler → CapableOf → provide flag	0.25
compiler → CapableOf → accept strict ansi c	0.25
compiler → CapableOf → provide standard ansi c preprocessor	0.25
compiler → CapableOf → take option	0.25
compiler → CapableOf → synthesize code	0.25
compiler → ReceivesAction → signed	0.25
compiler → CapableOf → generate common intermediate language	0.25
compiler → CapableOf → generate other specific format	0.25
compiler → HasA → feature	0.25
compiler → CapableOf → perform overload resolution	0.25
compiler → CapableOf → pack datum	0.25
compiler → CapableOf → know rule	0.25
compiler → CapableOf → use the value	0.25
compiler → ReceivesAction → encouraged to use the most frequent observations	0.25
compiler → CapableOf → bridge the gap	0.25
compiler → CapableOf → return result	0.25
compiler → CapableOf → leave the loop	0.25
compiler → HasA → all the information	0.25
compiler → CapableOf → compile much of the code	0.25
compiler → CapableOf → inform the runtime	0.25
compiler → CapableOf → generate the begin address	0.25
compiler → CapableOf → translate high-level instructions	0.25
compiler → CapableOf → count initializer	0.25
compiler → CapableOf → generate a backing field	0.25
compiler → CapableOf → optimize the copy	0.25
compiler → CapableOf → find match	0.25
compiler → CapableOf → search all ancestor classes	0.25
compiler → CapableOf → insert complete body of the function	0.25
compiler → CapableOf → avoid dangling pointer errors	0.25
compiler → CapableOf → allow the assignment of the object	0.25
compiler → CapableOf → convert varargs formal parameter	0.25
compiler → CapableOf → take as input source code	0.25
compiler → CapableOf → produce two output files	0.25
compiler → CapableOf → take while	0.25
compiler → HasPrerequisite → actual variable declaration	0.25
compiler → ReceivesAction → programmed in the coq proof assistant	0.25
compiler → HasA → a proof of total correctness	0.25
compiler → CapableOf → generate integer constant	0.25
compiler → CapableOf → attempt to find type	0.25
compiler → CapableOf → enforce type safety	0.25
compiler → CapableOf → understand new syntax	0.25
compiler → CapableOf → assume the strictest aliasing rules	0.25
compiler → CapableOf → step through the code	0.25
compiler → CapableOf → know element type of the collection	0.25
compiler → CapableOf → search in current scope	0.25
compiler → CapableOf → obey the nocopy hint	0.25
compiler → CapableOf → warn in c++	0.25
compiler → CapableOf → perform instruction scheduling	0.25
compiler → CapableOf → scan entire program	0.25
compiler → CapableOf → perform widening conversion	0.25
compiler → CapableOf → call the equals(object	0.25
compiler → ReceivesAction → licensed	0.25
compiler → CapableOf → generate intermediate form	0.25
compiler → ReceivesAction → intended to parse design descriptions	0.25
compiler → ReceivesAction → used by fast-growing scala community	0.25
compiler → CapableOf → generate il	0.25
compiler → CapableOf → detect call	0.25
compiler → CapableOf → check for translation	0.25
compiler → CapableOf → output hint	0.25
compiler → CapableOf → call into the attribute provider	0.25
compiler → ReceivesAction → deployed	0.25
compiler → CapableOf → generate the z80 restarts	0.25
compiler → CapableOf → generate im1	0.25
compiler → CapableOf → parse the expression	0.25
compiler → CapableOf → implement in thin client mode	0.25
compiler → CapableOf → select next gating branch	0.25
compiler → CapableOf → come with the board	0.25
compiler → CapableOf → use control flow	0.25
compiler → HasProperty → angry	0.24
compiler → HasProperty → powerful	0.23
compiler → HasProperty → complicated	0.23
compiler → HasProperty → portable	0.23
compiler → HasProperty → old	0.23
compiler → CapableOf → come with comprehensive help file	0.23
compiler → CapableOf → come with lots of ready-to-use examples	0.23
compiler → CapableOf → spend more time	0.21
compiler → CapableOf → stop the compilation	0.21
compiler → AtLocation → pass	0.21
compiler → HasProperty → necessary	0.20
compiler → ReceivesAction → unable to determine	0.19
compiler → CapableOf → generate special code	0.19
compiler → CapableOf → reject the program	0.19
compiler → HasProperty → robust	0.19
compiler → CapableOf → remove dead code	0.19
compiler → CapableOf → produce wrong answers	0.19
compiler → HasProperty → unhappy	0.19
compiler → HasProperty → expensive	0.19
compiler → HasPrerequisite → the programmer	0.18
compiler → CapableOf → emit definition	0.16
compiler → HasPrerequisite → browser	0.16
compiler → CapableOf → generate portable c code	0.16
compiler → CapableOf → generate better byte code	0.16
compiler → CapableOf → support openmp	0.16
compiler → CapableOf → show all the errors	0.16
compiler → CapableOf → generate more compact code	0.16
compiler → CapableOf → produce valid assembly code	0.16
compiler → CapableOf → record actual argument types	0.16
compiler → HasProperty → extensible	0.16
compiler → CapableOf → skip normal code	0.16
compiler → CapableOf → jump to the label	0.16
compiler → HasA → more freedom	0.16
compiler → CapableOf → fail to find such a type	0.16
compiler → CapableOf → improve performance	0.16
compiler → CapableOf → getting confused by the \	0.16
compiler → CapableOf → complain about all sorts of stuff	0.16
compiler → CapableOf → generate semantic error	0.16
compiler → CapableOf → handle rpc calls	0.16
compiler → CapableOf → spit out message	0.16
compiler → CapableOf → notify developer	0.16
compiler → CapableOf → ignore the request	0.13