code: def _process_instr_import_name(instr, queue, stack, body, context):
      
      # If this is "import module", fromlist is None.
      # If this this is "from module import a, b fromlist will be ('a', 'b').
      fromlist = stack.pop().arg
  
      # level argument to __import__.  Should be 0, 1, or 2.
      level = stack.pop().arg
  
      module = instr.arg
      if fromlist is None:  # Regular import.
          attr_loads = _pop_import_LOAD_ATTRs(module, queue)
          store = queue.popleft()
          # There are two cases where we should emit an alias:
          # import a as <anything but a>
          # import a.b.c as <anything (including a)>
          if attr_loads or module.split('.')[0] != store.arg:
              asname = store.arg
          else:
              asname = None
          body.append(
              ast.Import(
                  names=[
                      ast.alias(
                          name=module,
                          asname=(asname),
                      ),
                  ],
                  level=level,
              ),
          )
          return
      elif fromlist == ('*',):  # From module import *.
          expect(queue.popleft(), instrs.IMPORT_STAR, "after IMPORT_NAME")
          body.append(
              ast.ImportFrom(
                  module=module,
                  names=[ast.alias(name='*', asname=None)],
                  level=level,
              ),
          )
          return
  
      # Consume a pair of IMPORT_FROM, STORE_NAME instructions for each entry in
      # fromlist.
      names = list(map(make_importfrom_alias(queue, body, context), fromlist))
      body.append(ast.ImportFrom(module=module, names=names, level=level))
  
      # Remove the final POP_TOP of the imported module.
      expect(queue.popleft(), instrs.POP_TOP, "after 'from import'")
docs: Process an IMPORT_NAME instruction.
  
      Side Effects
      ------------
      Pops two instuctions from `stack`
      Consumes instructions from `queue` to the end of the import statement.
      Appends an ast.Import or ast.ImportFrom node to `body`.