}
    
    fn find_video_title<'a>(&'a self, url: &'a str) -> Result<String> {
        // Return the video title from <url> here.
        Ok("".to_string())
    }
    
    fn find_video_direct_url<'a>(&'a self, url: &'a str, onlyaudio: bool) -> Result<String> {
    	  // Return the direct download URL of the video (or its audio version) here.
    	  Ok("".to_string())
    }

    fn find_video_file_extension<'a>(&'a self, url: &'a str, onlyaudio: bool) -> Result<String> {
        // Return the designated file extension of the video (or audio) file here.
        Ok("mp4".to_string())
    }

    fn display_name<'a>(&'a self) -> String {
        // For cosmetics, this is the display name of this handler.
        "NoopExample"
    }

    // true, if the video exists.
    fn does_video_exist<'a>(&'a self, url: &'a str) -> Result<bool>;

    // returns the title of a video.
    fn find_video_title<'a>(&'a self, url: &'a str) -> Result<String>;

    // returns the download URL of a video.
    fn find_video_direct_url<'a>(&'a self, url: &'a str, onlyaudio: bool) -> Result<String>;

    // returns the file extension of the video (e.g. "mp4").
    fn find_video_file_extension<'a>(&'a self, url: &'a str, onlyaudio: bool) -> Result<String>;

    // returns the name of the site (e.g. "YouTube").
    fn display_name<'a>(&'a self) -> String;
}

            let video_info = get_video_info(id)?;
            let video_info_title = video_info["videoDetails"]["title"].as_str().unwrap_or("");

            Ok(String::from(video_info_title))
        }
    }

    fn find_video_direct_url<'a>(&'a self, url: &'a str, onlyaudio: bool) -> Result<String> {
        let id_regex = Regex::new(r"(?:v=|.be/)(.*$)").unwrap();
        let id = id_regex.captures(url).unwrap().get(1).unwrap().as_str();
        unsafe {
            let video_info = get_video_info(id)?;
            let video_info_itags = match video_info["streamingData"]["formats"].as_array() {
                None => return Ok("".to_string()),
                Some(itags) => itags,

                        && (this_vq == vq3 || this_vq == vq4 || this_vq == vq5 || this_vq == vq6))
                    || (last_vq == vq3 && (this_vq == vq4 || this_vq == vq5 || this_vq == vq6))
                    || (last_vq == vq4 && (this_vq == vq5 || this_vq == vq6))
                    || (last_vq == vq5 && this_vq == vq6);
                let is_same_or_better_video = (last_vq == this_vq) || is_better_video;

                let is_better_quality = is_better_audio && is_same_or_better_video
                    || (onlyaudio || is_better_video) && is_same_or_better_audio;

                if (!onlyaudio || itag["mimeType"].to_string().contains("video/"))
                    && (!onlyaudio || itag["quality"] != json!(null))
                    && itag["audioQuality"] != json!(null)
                    && (last_vq == "" || last_aq == "" || is_better_quality)
                {
                    VIDEO_MIME = itag["mimeType"].to_string();
                    url_to_choose = itag["url"].as_str().unwrap();
                    last_vq = String::from(this_vq);
                    last_aq = String::from(this_aq);

        }
    }

    fn display_name<'a>(&'a self) -> String {
        "YouTube".to_string()
    }

    fn find_video_file_extension<'a>(&'a self, _url: &'a str, _onlyaudio: bool) -> Result<String> {
        // By this point, we have already filled VIDEO_MIME. Let's just use that.
        unsafe {
            let mut ext = "mp4";
            if VIDEO_MIME.contains("/webm") {
                ext = "webm";
            }
            else if VIDEO_MIME.contains("audio/mp4") {
                ext = "m4a";
            }
            Ok(ext.to_string())
        }
    }
}

// Push the site definition to the list of known handlers:
inventory::submit! {
    &YouTubeHandler as &dyn SiteDefinition
}

                if vt.is_empty() {
                    println!("The video title could not be extracted. Invalid link?");
                } else {
                    if args.is_present("verbose") {
                        println!("Title: {}", vt);
                    }

                    let ext =
                        handler.find_video_file_extension(in_url, args.is_present("onlyaudio"))?;
                    let url =
                        handler.find_video_direct_url(in_url, args.is_present("onlyaudio"))?;

                    // Now let's download it:
                    let mut targetfile = format!(
                        "{}.{}",
                        vt.replace(&['\"', ':', '\'', '\\', '/'][..], "-"),
                        ext
                    );

                    if let Some(in_targetfile) = args.value_of("outputfile") {
                        targetfile = in_targetfile.to_string();
                    }

                    if args.is_present("verbose") {
                        println!("Starting the download.");
                    }

                    download(&url, &targetfile)?;

                    // Convert the file if needed.
                    let mut outputext = "mp3";
                    if let Some(in_outputext) = args.value_of("audioformat") {
                        outputext = &in_outputext;
                    }

                    if args.is_present("onlyaudio") && ext != outputext {
                        if args.is_present("verbose") {
                            println!("Post-processing.");
                        }

                        // Convert the file if needed.
                        let mut outputext = "mp3";
                        if let Some(in_outputext) = args.value_of("audioformat") {
                            outputext = &in_outputext;
                        }

                        let inpath = Path::new(&targetfile);
                        let mut outpathbuf = PathBuf::from(&targetfile);