Use backtick code blocks for syntax highlighting

09-07.md

@@ -52,11 +52,13 @@ PTR 1000:5**, but you'd be wrong. That won't even assemble. You might
 then think to construct in memory a far pointer containing 1000:5, as in
 the following:
 
-    Ptr  dd   ?
-         :
-         mov  word ptr [Ptr],5
-         mov  word ptr [Ptr+2],1000h
-         jmp  [Ptr]
+```nasm
+Ptr  dd   ?
+     :
+     mov  word ptr [Ptr],5
+     mov  word ptr [Ptr+2],1000h
+     jmp  [Ptr]
+```
 
 That will work, but at a price in performance. On an 8088, **JMP DWORD
 PTR [*mem*]** (an indirect far jump) takes at least 37 cycles; **JMP
@@ -87,22 +89,24 @@ solution; if you have one, pass it along.
 
 **LISTING 9.7 L9-7.ASM**
 
-    ; Program to perform a direct far jump to address 1000:5.
-    ; *** Do not run this program! It's just an example of how ***
-    ; *** to build a direct far jump to an absolute address    ***
-    ;
-    ; Tested with TASM 2 and MASM 5.
+```nasm
+; Program to perform a direct far jump to address 1000:5.
+; *** Do not run this program! It's just an example of how ***
+; *** to build a direct far jump to an absolute address    ***
+;
+; Tested with TASM 2 and MASM 5.
 
-    FarSeg     segment  at 01000h
-          org  5
-    FarLabel label  far
-    FarSeg      ends
+FarSeg     segment  at 01000h
+      org  5
+FarLabel label  far
+FarSeg      ends
 
-          .model     small
-          .code
-    start:
-          jmp     FarLabel
-          end     start
+      .model     small
+      .code
+start:
+      jmp     FarLabel
+      end     start
+```
 
 By the way, if you're wondering how I figured this out, I merely applied
 my good friend Dan Illowsky's long-standing rule for dealing with MASM:
@@ -116,12 +120,16 @@ something that does—a rule with plenty of history on its side.
 To finish up this chapter, consider these two items. First, in 32-bit
 protected mode,
 
-    sub  eax,eax
-    inc  eax
+```nasm
+sub  eax,eax
+inc  eax
+```
 
 takes 4 cycles to execute, but is only 3 bytes long, while
 
-    mov  eax,1
+```nasm
+mov  eax,1
+```
 
 takes only 2 cycles to execute, but is 5 bytes long (because native mode
 constants are dwords and the **MOV** instruction doesn't sign-extend).
@@ -129,11 +137,15 @@ Both code fragments are ways to set **EAX** to 1 (although the first
 affects the flags and the second doesn't); this is a classic trade-off
 of speed for space. Second,
 
-    or    ebx,-1
+```nasm
+or    ebx,-1
+```
 
 takes 2 cycles to execute and is 3 bytes long, while
 
-    move  bx,-1
+```nasm
+move  bx,-1
+```
 
 takes 2 cycles to execute and is 5 bytes long. Both instructions set
 **EBX** to -1; this is a classic trade-off of—gee, it's not a trade-off