let lexbuf outchan l =
  Id.counter := 0;
  Typing.extenv := M.empty;
  Emit.f outchan
    (RegAlloc.f
       (Simm.f
          (Virtual.f
             (Closure.f
                (iter !limit
                   (Alpha.f
                      (KNormal.f
                         (Typing.f
                            (Parser.exp Lexer.token l)))))))))

  | NonTail(x), Set(i) -> Printf.fprintf oc "\tmovl\t$%d, %s\n" i x
  | NonTail(x), Mov(y) ->
      if x <> y then Printf.fprintf oc "\tmovl\t%s, %s\n" y x
  | NonTail(x), Neg(y) ->
      if x <> y then Printf.fprintf oc "\tmovl\t%s, %s\n" y x;
      Printf.fprintf oc "\tnegl\t%s\n" x
  | NonTail(x), Add(y, z') ->
      if V(x) = z' then
        Printf.fprintf oc "\taddl\t%s, %s\n" y x
      else
        (if x <> y then Printf.fprintf oc "\tmovl\t%s, %s\n" y x;
         Printf.fprintf oc "\taddl\t%s, %s\n" (pp_id_or_imm z') x)

  | NonTail(x), Set(i) -> movl  ${i}, {x}
  | NonTail(x), Mov(y) -> movl  {y}, {x} -- if x <> y
  | NonTail(x), Neg(y) -> movl  {y}, {x} -- if x <> y
                          negl  {x}
  | NonTail(x), Add(y, z') ->    (* x := y - z' *)
      addl  {y}, {x}             -- if V(x) = z'
      movl  {y}, {x}             -- else if x <> y
      addl  {pp_id_or_imm z'}, x -- otherwise

  | NonTail(z), IfEq(x, y', e1, e2) ->
      Printf.fprintf oc "\tcmpl\t%s, %s\n" (pp_id_or_imm y') x;
      g'_non_tail_if oc (NonTail(z)) e1 e2 "je" "jne"

and g'_non_tail_if oc dest e1 e2 b bn =
  let b_else = Id.genid (b ^ "_else") in
  let b_cont = Id.genid (b ^ "_cont") in
            {bn}  {b_else}
            g oc (dest, e1);
            jmp  {b_cont}
  {b_else}:
            g oc (dest, e2);
  {b_cont}:

  | NonTail(a), CallDir(Id.L(x), ys, zs) ->
      g'_args oc [] ys zs;
      let ss = stacksize () in
      if ss > 0 then Printf.fprintf oc "\taddl\t$%d, %s\n" ss reg_sp;
      Printf.fprintf oc "\tcall\t%s\n" x;
      if ss > 0 then Printf.fprintf oc "\tsubl\t$%d, %s\n" ss reg_sp;
      if List.mem a allregs && a <> regs.(0) then
        Printf.fprintf oc "\tmovl\t%s, %s\n" regs.(0) a
      else if List.mem a allfregs && a <> fregs.(0) then
        Printf.fprintf oc "\tmovsd\t%s, %s\n" fregs.(0) a

  | NonTail(a), CallDir(Id.L(x), ys, zs) ->
      g'_args oc [] ys zs;
      let ss = stacksize () in
      addl   {ss},  {reg_sp} -- if ss > 0
      call   {x}
      subl   {ss},  {reg_sp} -- if ss > 0
      movl   %eax,  {a}      -- if List.mem a allregs && a <> %eax
      movsd  %xmm0, {a}      -- else if List.mem a allfregs && a <> %xmm0

  | NonTail(a), CallCls(x, ys, zs) ->
      g'_args oc [(x, reg_cl)] ys zs;
      let ss = stacksize () in
      if ss > 0 then Printf.fprintf oc "\taddl\t$%d, %s\n" ss reg_sp;
      Printf.fprintf oc "\tcall\t*(%s)\n" reg_cl;
      if ss > 0 then Printf.fprintf oc "\tsubl\t$%d, %s\n" ss reg_sp;
      if List.mem a allregs && a <> regs.(0) then
        Printf.fprintf oc "\tmovl\t%s, %s\n" regs.(0) a
      else if List.mem a allfregs && a <> fregs.(0) then
        Printf.fprintf oc "\tmovsd\t%s, %s\n" fregs.(0) a

  | NonTail(a), CallCls(x, ys, zs) ->
      g'_args oc [(x, reg_cl)] ys zs;
      let ss = stacksize () in
      addl  {ss},   {reg_sp}  -- if ss > 0
      call  *({reg_cl})
      subl  ${ss},  {reg_sp}  -- if ss > 0
      movl  %eax,   {a}       -- if List.mem a allregs && a <> %eax
      movsd %xmm0,  {a}       -- if List.mem a allfregs && a <> %xmm0

  | Tail, CallCls(x, ys, zs) -> (* 末尾呼び出し (caml2html: emit_tailcall) *)
      g'_args oc [(x, reg_cl)] ys zs;
 
  | Tail, CallCls(x, ys, zs) -> (* 末尾呼び出し (caml2html: emit_tailcall) *)
      g'_args oc [(x, reg_cl)] ys zs;
      Printf.fprintf oc "\tjmp\t*(%s)\n" reg_cl

  | Tail, CallDir(Id.L(x), ys, zs) ->
      g'_args oc [] ys zs;
      jmp  *({x})
 
  | Tail, CallCls(x, ys, zs) ->
      g'_args oc [(x, reg_cl)] ys zs;
      jmp  *({reg_cl})