You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: lea_dynamic_calls.rs
    path of file: ./repos/rustig/lib/callgraph/src/callgraph
    
    the code of the file until where you have to start completion: // (C) COPYRIGHT 2018 TECHNOLUTION BV, GOUDA NL

// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

extern crate byteorder;
extern crate capstone;

use Context;
use InlineFunctionFrame;
use Invocation;
use InvocationType;
use Procedure;

use byteorder::{LittleEndian, ReadBytesExt};

use callgraph::fallible_iterator::FallibleIterator;
use callgraph::InvocationFinder;

use capstone::arch::x86::X86OpMem;
use capstone::arch::x86::X86OperandType;
use capstone::arch::ArchOperand;
use capstone::Insn;
use capstone::InsnDetail;
use capstone::RegId;

use object::ElfSection;
use object::Object;
use object::ObjectSect
    
    fn parse<'a>(file_content: &'a [u8]) -> Context<'a> {
        let elf = ElfFile::parse(&file_content).expect("Failed to parse file content");
        let file = File::parse(&file_content).expect("Failed to parse file content");
        let file_context =
            Addr2LineContext::new(&file).expect("Could not construct context from file");

        let endianness = gimli::LittleEndian;
        let mode = capstone::arch::x86::ArchMode::Mode64;

        let debug_info_data = elf.section_data_by_name(".debug_info")
            .expect("No .debug_info section in binary");
        let dwarf_info = DebugInfo::new(debug_info_data, endianness);

        let debug_abbrev_data = elf.section_data_by_name(".debug_abbrev")
            .expect("No .debug_abbrev section in binary");
        let dwarf_abbrev = DebugAbbrev::new(debug_abbrev_data, endianness);

        let debug_str_data = elf.section_data_by_name(".debug_str")
            .expect("No .debug_str section in binary");
        let dwarf_strings = DebugStr::new(debug_str_data, endianness);

        let debug_line_data = elf.section_data_by_name(".debug_line")
            .expect("No .debug_line section in binary");
        let dwarf_line = DebugLine::new(debug_line_data, endianness);

        let mut capstone = Capstone::new()
            .x86()
            .mode(mode)
            .detail(true)
            .build()
            .expect("Failed to construct disassembler");
        capstone
            .set_detail(true)
            .expect("Failed to enable detailed mode");

        Context {
            elf,
            file_context,
            dwarf_info,
            dwarf_abbrev,
            dwarf_strings,
            dwarf_line,
            capstone,
        }
    }