Use backtick code blocks for syntax highlighting

11-08.md

@@ -43,22 +43,24 @@ a segment and an offset. We'll also branch backward so that the address
 pushed on the stack will point to the instruction we want to continue
 with. The code works out like this:
 
-          jmpshort popfskip
-    popfiret:
-          iret;      branches to the instruction after the
-                     ; call, popping the word below the address
-                     ; pushed by CALL into the FLAGS register
-    popfskip:
-          call  far ptr popfiret
-                     ;pushes the segment:offset of the next
-                     ; instruction on the stack just above
-                     ; the flags word, setting things up so
-                     ; that IRET will branch to the next
-                     ; instruction and pop the flags
-    ; When execution reaches the instruction following this comment,
-    ; the word that was on top of the stack when JMP SHORT POPFSKIP
-    ; was reached has been popped into the FLAGS register, just as
-    ; if a POPF instruction had been executed.
+```nasm
+      jmpshort popfskip
+popfiret:
+      iret;      branches to the instruction after the
+                 ; call, popping the word below the address
+                 ; pushed by CALL into the FLAGS register
+popfskip:
+      call  far ptr popfiret
+                 ;pushes the segment:offset of the next
+                 ; instruction on the stack just above
+                 ; the flags word, setting things up so
+                 ; that IRET will branch to the next
+                 ; instruction and pop the flags
+; When execution reaches the instruction following this comment,
+; the word that was on top of the stack when JMP SHORT POPFSKIP
+; was reached has been popped into the FLAGS register, just as
+; if a POPF instruction had been executed.
+```
 
 ![**Figure 11.5**  *The operation of IRET.*](images/11-05.jpg)
 
@@ -68,26 +70,30 @@ The **POPF** workaround can best be implemented as a macro; we can also
 emulate a far call by pushing CS and performing a near call, thereby
 shrinking the workaround code by 1 byte:
 
-    EMULATE_POPF             macro
-         local popfskip, popfiret
-         jmp   short popfskip
-    popfiret:
-         iret
-    popfskip:
-         push  cs
-         call  popfiret
-         endm
+```nasm
+EMULATE_POPF             macro
+     local popfskip, popfiret
+     jmp   short popfskip
+popfiret:
+     iret
+popfskip:
+     push  cs
+     call  popfiret
+     endm
+```
 
 By the way, the flags can be popped much more quickly if you're willing
 to alter a register in the process. For example, the following macro
 emulates **POPF** with just one branch, but wipes out AX:
 
-    EMULATE_POPF_TRASH_AX   macro
-       push  cs
-       mov   ax,offset $+5
-       push  ax
-       iret
-       endm
+```nasm
+EMULATE_POPF_TRASH_AX   macro
+   push  cs
+   mov   ax,offset $+5
+   push  ax
+   iret
+   endm
+```
 
 It's not a perfect substitute for **POPF**, since **POPF** doesn't alter
 any registers, but it's faster and shorter than **EMULATE\_POPF** when
@@ -96,13 +102,15 @@ you can use which is shorter still, alters no registers, and branches
 just once. (Of course, this version of **EMULATE\_POPF** won't work on
 an 8088.)
 
-          .286
-                     :
-    EMULATE_POPFmacro
-          pushcs
-          pushoffset $+4
-          iret
-          endm
+```nasm
+      .286
+                 :
+EMULATE_POPFmacro
+      pushcs
+      pushoffset $+4
+      iret
+      endm
+```
 
 ![**Figure 11.6**  *Workaround code for the POPF bug.*](images/11-06.jpg)