diff --git a/src/main.rs b/src/main.rs
index aa058f7..231679e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,290 +6,290 @@ use anyhow::Result as AResult;
 #[command(author, version, about, long_about = None)]
 #[command(propagate_version = true)]
 struct Cli {
-    #[command(subcommand)]
-    command: Commands,
+	#[command(subcommand)]
+	command: Commands,
 }
 
 #[derive(Subcommand)]
 enum Commands {
-    Download(MapList),
-    DownloadTextures(PathBufList),
-    ConvertTextures,
-    DownloadMeshes(PathBufList),
-    Extract(PathBufList),
-    WriteAttributes,
-    Interactive,
-    Replace,
-    Scan,
-    UnzipAll,
-    Upload,
+	Download(MapList),
+	DownloadTextures(PathBufList),
+	ConvertTextures,
+	DownloadMeshes(PathBufList),
+	Extract(PathBufList),
+	WriteAttributes,
+	Interactive,
+	Replace,
+	Scan,
+	UnzipAll,
+	Upload,
 }
 
 #[derive(Args)]
 struct PathBufList {
-    paths:Vec<std::path::PathBuf>
+	paths:Vec<std::path::PathBuf>
 }
 
 #[derive(Args)]
 struct MapList {
-    maps: Vec<u64>,
+	maps: Vec<u64>,
 }
 
 fn class_is_a(class: &str, superclass: &str) -> bool {
-    if class==superclass {
-        return true
-    }
-    let class_descriptor=rbx_reflection_database::get().classes.get(class);
-    if let Some(descriptor) = &class_descriptor {
-        if let Some(class_super) = &descriptor.superclass {
-            return class_is_a(&class_super, superclass)
-        }
-    }
-    return false
+	if class==superclass {
+		return true
+	}
+	let class_descriptor=rbx_reflection_database::get().classes.get(class);
+	if let Some(descriptor) = &class_descriptor {
+		if let Some(class_super) = &descriptor.superclass {
+			return class_is_a(&class_super, superclass)
+		}
+	}
+	return false
 }
 fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
-    for &referent in instance.children() {
-        if let Some(c) = dom.get_by_ref(referent) {
-            if class_is_a(c.class.as_str(), superclass) {
-                objects.push(c.referent());//copy ref
-            }
-            recursive_collect_superclass(objects,dom,c,superclass);
-        }
-    }
+	for &referent in instance.children() {
+		if let Some(c) = dom.get_by_ref(referent) {
+			if class_is_a(c.class.as_str(), superclass) {
+				objects.push(c.referent());//copy ref
+			}
+			recursive_collect_superclass(objects,dom,c,superclass);
+		}
+	}
 }
 fn recursive_collect_regex(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, regex: &lazy_regex::Lazy<lazy_regex::Regex>){
-    for &referent in instance.children() {
-        if let Some(c) = dom.get_by_ref(referent) {
-            if regex.captures(c.name.as_str()).is_some(){
-                objects.push(c.referent());//copy ref
-            }
-            recursive_collect_regex(objects,dom,c,regex);
-        }
-    }
+	for &referent in instance.children() {
+		if let Some(c) = dom.get_by_ref(referent) {
+			if regex.captures(c.name.as_str()).is_some(){
+				objects.push(c.referent());//copy ref
+			}
+			recursive_collect_regex(objects,dom,c,regex);
+		}
+	}
 }
 fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance) -> String{
-    let mut full_name=instance.name.clone();
-    let mut pref=instance.parent();
-    while let Some(parent)=dom.get_by_ref(pref){
-        full_name.insert(0, '.');
-        full_name.insert_str(0, &parent.name);
-        pref=parent.parent();
-    }
-    full_name
+	let mut full_name=instance.name.clone();
+	let mut pref=instance.parent();
+	while let Some(parent)=dom.get_by_ref(pref){
+		full_name.insert(0, '.');
+		full_name.insert_str(0, &parent.name);
+		pref=parent.parent();
+	}
+	full_name
 }
 
 //download
-    //download list of maps to maps/unprocessed
+	//download list of maps to maps/unprocessed
 //scan (scripts)
-    //iter maps/unprocessed
-    //passing moves to maps/verified
-    //failing moves to maps/blocked
+	//iter maps/unprocessed
+	//passing moves to maps/verified
+	//failing moves to maps/blocked
 //replace (edits & deletions)
-    //iter maps/blocked
-    //replace scripts and put in maps/unprocessed
+	//iter maps/blocked
+	//replace scripts and put in maps/unprocessed
 //upload
-    //iter maps/verified
-    //interactively print DisplayName/Creator and ask for target upload ids
+	//iter maps/verified
+	//interactively print DisplayName/Creator and ask for target upload ids
 //interactive
-    //iter maps/unprocessed
-    //for each unique script, load it into the file current.lua and have it open in sublime text
-    //I can edit the file and it will edit it in place
-    //I pass/fail(with comment)/allow each script
+	//iter maps/unprocessed
+	//for each unique script, load it into the file current.lua and have it open in sublime text
+	//I can edit the file and it will edit it in place
+	//I pass/fail(with comment)/allow each script
 
 fn get_script_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
-    let mut scripts = std::vec::Vec::new();
-    recursive_collect_superclass(&mut scripts, dom, dom.root(),"LuaSourceContainer");
-    scripts
+	let mut scripts = std::vec::Vec::new();
+	recursive_collect_superclass(&mut scripts, dom, dom.root(),"LuaSourceContainer");
+	scripts
 }
 fn get_button_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
-    let mut buttons = std::vec::Vec::new();
-    recursive_collect_regex(&mut buttons, dom, dom.root(),lazy_regex::regex!(r"Button(\d+)$"));
-    buttons
+	let mut buttons = std::vec::Vec::new();
+	recursive_collect_regex(&mut buttons, dom, dom.root(),lazy_regex::regex!(r"Button(\d+)$"));
+	buttons
 }
 fn get_texture_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
-    let mut objects = std::vec::Vec::new();
-    recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
-    //get ids
-    //clear vec
-    //next class
-    objects
+	let mut objects = std::vec::Vec::new();
+	recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
+	//get ids
+	//clear vec
+	//next class
+	objects
 }
 fn get_mesh_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
-    let mut objects = std::vec::Vec::new();
-    recursive_collect_superclass(&mut objects, dom, dom.root(),"FileMesh");
-    recursive_collect_superclass(&mut objects, dom, dom.root(),"MeshPart");
-    //get ids
-    //clear vec
-    //next class
-    objects
+	let mut objects = std::vec::Vec::new();
+	recursive_collect_superclass(&mut objects, dom, dom.root(),"FileMesh");
+	recursive_collect_superclass(&mut objects, dom, dom.root(),"MeshPart");
+	//get ids
+	//clear vec
+	//next class
+	objects
 }
 
 enum ReaderType<'a, R:Read+Seek>{
-    GZip(flate2::read::GzDecoder<&'a mut R>),
-    Raw(&'a mut R),
+	GZip(flate2::read::GzDecoder<&'a mut R>),
+	Raw(&'a mut R),
 }
 
 fn maybe_gzip_decode<R:Read+Seek>(input:&mut R)->AResult<ReaderType<R>>{
-    let mut first_2=[0u8;2];
-    if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_2),std::io::Seek::rewind(input)){
-        match &first_2{
-            b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(input))),
-            _=>Ok(ReaderType::Raw(input)),
-        }
-    }else{
-        Err(anyhow::Error::msg("failed to peek"))
-    }
+	let mut first_2=[0u8;2];
+	if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_2),std::io::Seek::rewind(input)){
+		match &first_2{
+			b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(input))),
+			_=>Ok(ReaderType::Raw(input)),
+		}
+	}else{
+		Err(anyhow::Error::msg("failed to peek"))
+	}
 }
 
 fn load_dom<R:Read+Seek>(input:&mut R)->AResult<rbx_dom_weak::WeakDom>{
-    let mut first_8=[0u8;8];
-    if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_8),std::io::Seek::rewind(input)){
-        match &first_8[0..4]{
-            b"<rob"=>{
-                match &first_8[4..8]{
-                    b"lox!"=>return rbx_binary::from_reader(input).map_err(anyhow::Error::msg),
-                    b"lox "=>return rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(anyhow::Error::msg),
-                    other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))),
-                }
-            },
-            _=>Err(anyhow::Error::msg("unsupported file type")),
-        }
-    }else{
-        Err(anyhow::Error::msg("peek failed"))
-    }
+	let mut first_8=[0u8;8];
+	if let (Ok(()),Ok(()))=(std::io::Read::read_exact(input, &mut first_8),std::io::Seek::rewind(input)){
+		match &first_8[0..4]{
+			b"<rob"=>{
+				match &first_8[4..8]{
+					b"lox!"=>return rbx_binary::from_reader(input).map_err(anyhow::Error::msg),
+					b"lox "=>return rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(anyhow::Error::msg),
+					other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))),
+				}
+			},
+			_=>Err(anyhow::Error::msg("unsupported file type")),
+		}
+	}else{
+		Err(anyhow::Error::msg("peek failed"))
+	}
 }
 
 fn get_dom<R:Read+Seek>(input:&mut R)->AResult<rbx_dom_weak::WeakDom>{
-    match maybe_gzip_decode(input){
-        Ok(ReaderType::GZip(mut readable)) => {
-            //gzip
-            let mut extracted:Vec<u8>=Vec::new();
-            readable.read_to_end(&mut extracted)?;
-            Ok(load_dom(&mut std::io::Cursor::new(extracted))?)
-        },
-        Ok(ReaderType::Raw(readable)) => Ok(load_dom(readable)?),
-        Err(e) => Err(e)?,
-    }
+	match maybe_gzip_decode(input){
+		Ok(ReaderType::GZip(mut readable)) => {
+			//gzip
+			let mut extracted:Vec<u8>=Vec::new();
+			readable.read_to_end(&mut extracted)?;
+			Ok(load_dom(&mut std::io::Cursor::new(extracted))?)
+		},
+		Ok(ReaderType::Raw(readable)) => Ok(load_dom(readable)?),
+		Err(e) => Err(e)?,
+	}
 }
 
 fn get_id() -> AResult<u32>{
-    match std::fs::read_to_string("id"){
-        Ok(id_file)=>Ok(id_file.parse::<u32>()?),
-        Err(e) => match e.kind() {
-            std::io::ErrorKind::NotFound => Ok(0),//implicitly take on id=0
-            _ => Err(e)?,
-        }
-    }
+	match std::fs::read_to_string("id"){
+		Ok(id_file)=>Ok(id_file.parse::<u32>()?),
+		Err(e) => match e.kind() {
+			std::io::ErrorKind::NotFound => Ok(0),//implicitly take on id=0
+			_ => Err(e)?,
+		}
+	}
 }
 
 fn get_set_from_file(file:&str) -> AResult<std::collections::HashSet<String>>{
-    let mut set=std::collections::HashSet::<String>::new();
-    for entry in std::fs::read_dir(file)? {
-        set.insert(std::fs::read_to_string(entry?.path())?);
-    }
-    Ok(set)
+	let mut set=std::collections::HashSet::<String>::new();
+	for entry in std::fs::read_dir(file)? {
+		set.insert(std::fs::read_to_string(entry?.path())?);
+	}
+	Ok(set)
 }
 
 fn get_allowed_set() -> AResult<std::collections::HashSet<String>>{
-    get_set_from_file("scripts/allowed")
+	get_set_from_file("scripts/allowed")
 }
 
 fn get_blocked() -> AResult<std::collections::HashSet<String>>{
-    get_set_from_file("scripts/blocked")
+	get_set_from_file("scripts/blocked")
 }
 
 fn get_allowed_map() -> AResult<std::collections::HashMap::<u32,String>>{
-    let mut allowed_map = std::collections::HashMap::<u32,String>::new();
-    for entry in std::fs::read_dir("scripts/allowed")? {
-        let entry=entry?;
-        allowed_map.insert(entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?,std::fs::read_to_string(entry.path())?);
-    }
-    Ok(allowed_map)
+	let mut allowed_map = std::collections::HashMap::<u32,String>::new();
+	for entry in std::fs::read_dir("scripts/allowed")? {
+		let entry=entry?;
+		allowed_map.insert(entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?,std::fs::read_to_string(entry.path())?);
+	}
+	Ok(allowed_map)
 }
 
 fn get_replace_map() -> AResult<std::collections::HashMap::<String,u32>>{
-    let mut replace = std::collections::HashMap::<String,u32>::new();
-    for entry in std::fs::read_dir("scripts/replace")? {
-        let entry=entry?;
-        replace.insert(std::fs::read_to_string(entry.path())?,entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?);
-    }
-    Ok(replace)
+	let mut replace = std::collections::HashMap::<String,u32>::new();
+	for entry in std::fs::read_dir("scripts/replace")? {
+		let entry=entry?;
+		replace.insert(std::fs::read_to_string(entry.path())?,entry.path().file_stem().unwrap().to_str().unwrap().parse::<u32>()?);
+	}
+	Ok(replace)
 }
 
 fn check_source_illegal_keywords(source:&String)->bool{
-    source.find("getfenv").is_some()||source.find("require").is_some()
+	source.find("getfenv").is_some()||source.find("require").is_some()
 }
 
 fn find_first_child_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&'a rbx_dom_weak::Instance,name:&'a str,class:&'a str) -> Option<&'a rbx_dom_weak::Instance> {
-    for &referent in instance.children() {
-        if let Some(c) = dom.get_by_ref(referent) {
-            if c.name==name&&class_is_a(c.class.as_str(),class) {
-                return Some(c);
-            }
-        }
-    }
-    None
+	for &referent in instance.children() {
+		if let Some(c) = dom.get_by_ref(referent) {
+			if c.name==name&&class_is_a(c.class.as_str(),class) {
+				return Some(c);
+			}
+		}
+	}
+	None
 }
 
 fn get_mapinfo(dom:&rbx_dom_weak::WeakDom) -> AResult<(String,String,String)>{
-    let workspace_children=dom.root().children();
-    if workspace_children.len()!=1{
-        return Err(anyhow::Error::msg("there can only be one model"));
-    }
-    if let Some(model_instance) = dom.get_by_ref(workspace_children[0]) {
-        if let (Some(creator),Some(displayname))=(find_first_child_class(dom, model_instance, "Creator", "StringValue"),find_first_child_class(dom, model_instance, "DisplayName", "StringValue")){
-            if let (
-                Some(rbx_dom_weak::types::Variant::String(creator_string)),
-                Some(rbx_dom_weak::types::Variant::String(displayname_string))
-            )=(
-                creator.properties.get("Value"),
-                displayname.properties.get("Value")
-            ){
-                return Ok((model_instance.name.clone(),creator_string.clone(),displayname_string.clone()));
-            }
-        }
-    }
-    return Err(anyhow::Error::msg("no stuff in map"));
+	let workspace_children=dom.root().children();
+	if workspace_children.len()!=1{
+		return Err(anyhow::Error::msg("there can only be one model"));
+	}
+	if let Some(model_instance) = dom.get_by_ref(workspace_children[0]) {
+		if let (Some(creator),Some(displayname))=(find_first_child_class(dom, model_instance, "Creator", "StringValue"),find_first_child_class(dom, model_instance, "DisplayName", "StringValue")){
+			if let (
+				Some(rbx_dom_weak::types::Variant::String(creator_string)),
+				Some(rbx_dom_weak::types::Variant::String(displayname_string))
+			)=(
+				creator.properties.get("Value"),
+				displayname.properties.get("Value")
+			){
+				return Ok((model_instance.name.clone(),creator_string.clone(),displayname_string.clone()));
+			}
+		}
+	}
+	return Err(anyhow::Error::msg("no stuff in map"));
 }
 
 fn download(map_list: Vec<u64>) -> AResult<()>{
-    let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
-    let shared_args=&[
-        "-q",
-        "--header",
-        header.as_str(),
-        "-O",
-    ];
-    let processes_result:Result<Vec<_>, _>=map_list.iter().map(|map_id|{
-        std::process::Command::new("wget")
-        .args(shared_args)
-        .arg(format!("maps/unprocessed/{}.rbxm",map_id))
-        .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",map_id))
-        .spawn()
-    }).collect();
-    //naively wait for all because idk how to make an async progress bar lmao
-    for child in processes_result?{
-        let output=child.wait_with_output()?;
-        println!("map exit_success:{}",output.status.success());
-    }
-    Ok(())
+	let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
+	let shared_args=&[
+		"-q",
+		"--header",
+		header.as_str(),
+		"-O",
+	];
+	let processes_result:Result<Vec<_>, _>=map_list.iter().map(|map_id|{
+		std::process::Command::new("wget")
+		.args(shared_args)
+		.arg(format!("maps/unprocessed/{}.rbxm",map_id))
+		.arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",map_id))
+		.spawn()
+	}).collect();
+	//naively wait for all because idk how to make an async progress bar lmao
+	for child in processes_result?{
+		let output=child.wait_with_output()?;
+		println!("map exit_success:{}",output.status.success());
+	}
+	Ok(())
 }
 
 struct RobloxAssetId(u64);
 struct RobloxAssetIdParseErr;
 impl std::str::FromStr for RobloxAssetId {
-    type Err=RobloxAssetIdParseErr;
-    fn from_str(s: &str) -> Result<Self, Self::Err>{
-        let regman=lazy_regex::regex!(r"(\d+)$");
-        if let Some(captures) = regman.captures(s) {
-            if captures.len()==2{//captures[0] is all captures concatenated, and then each individual capture
-                if let Ok(id) = captures[0].parse::<u64>() {
-                    return Ok(Self(id));
-                }
-            }
-        }
-        Err(RobloxAssetIdParseErr)
-    }
+	type Err=RobloxAssetIdParseErr;
+	fn from_str(s: &str) -> Result<Self, Self::Err>{
+		let regman=lazy_regex::regex!(r"(\d+)$");
+		if let Some(captures) = regman.captures(s) {
+			if captures.len()==2{//captures[0] is all captures concatenated, and then each individual capture
+				if let Ok(id) = captures[0].parse::<u64>() {
+					return Ok(Self(id));
+				}
+			}
+		}
+		Err(RobloxAssetIdParseErr)
+	}
 }
 /* The ones I'm interested in:
 Beam.Texture
@@ -318,723 +318,723 @@ SurfaceAppearance.RoughnessMap
 SurfaceAppearance.TexturePack
 */
 fn download_textures(paths: Vec<std::path::PathBuf>) -> AResult<()>{
-    println!("download_textures paths:{:?}",paths);
-    let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
-    let shared_args=&[
-        "-q",
-        "--header",
-        header.as_str(),
-        "-O",
-    ];
-    let mut texture_list=std::collections::HashSet::new();
-    for path in paths {
-        let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);
+	println!("download_textures paths:{:?}",paths);
+	let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
+	let shared_args=&[
+		"-q",
+		"--header",
+		header.as_str(),
+		"-O",
+	];
+	let mut texture_list=std::collections::HashSet::new();
+	for path in paths {
+		let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);
 
-        match get_dom(&mut input){
-            Ok(dom)=>{
-                let object_refs = get_texture_refs(&dom);
-                for &object_ref in object_refs.iter() {
-                    if let Some(object)=dom.get_by_ref(object_ref){
-                        if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("Texture") {
-                            println!("Texture content:{:?}",content);
-                            if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
-                                texture_list.insert(asset_id.0);
-                            }
-                        }
-                    }
-                }
-            },
-            Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
-        }
-    }
-    println!("Texture list:{:?}",texture_list);
-    let processes_result:Result<Vec<_>, _>=texture_list.iter().map(|asset_id|{
-        std::process::Command::new("wget")
-        .args(shared_args)
-        .arg(format!("textures/unprocessed/{}",asset_id))
-        .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
-        .spawn()
-    }).collect();
-    //naively wait for all because idk how to make an async progress bar lmao
-    for child in processes_result?{
-        let output=child.wait_with_output()?;
-        println!("texture exit_success:{}",output.status.success());
-    }
-    Ok(())
+		match get_dom(&mut input){
+			Ok(dom)=>{
+				let object_refs = get_texture_refs(&dom);
+				for &object_ref in object_refs.iter() {
+					if let Some(object)=dom.get_by_ref(object_ref){
+						if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("Texture") {
+							println!("Texture content:{:?}",content);
+							if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
+								texture_list.insert(asset_id.0);
+							}
+						}
+					}
+				}
+			},
+			Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
+		}
+	}
+	println!("Texture list:{:?}",texture_list);
+	let processes_result:Result<Vec<_>, _>=texture_list.iter().map(|asset_id|{
+		std::process::Command::new("wget")
+		.args(shared_args)
+		.arg(format!("textures/unprocessed/{}",asset_id))
+		.arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
+		.spawn()
+	}).collect();
+	//naively wait for all because idk how to make an async progress bar lmao
+	for child in processes_result?{
+		let output=child.wait_with_output()?;
+		println!("texture exit_success:{}",output.status.success());
+	}
+	Ok(())
 }
 fn download_meshes(paths: Vec<std::path::PathBuf>) -> AResult<()>{
-    println!("download_meshes paths:{:?}",paths);
-    let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
-    let shared_args=&[
-        "-q",
-        "--header",
-        header.as_str(),
-        "-O",
-    ];
-    let mut mesh_list=std::collections::HashSet::new();
-    for path in paths {
-        let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);
+	println!("download_meshes paths:{:?}",paths);
+	let header=format!("Cookie: .ROBLOSECURITY={}",std::env::var("RBXCOOKIE")?);
+	let shared_args=&[
+		"-q",
+		"--header",
+		header.as_str(),
+		"-O",
+	];
+	let mut mesh_list=std::collections::HashSet::new();
+	for path in paths {
+		let mut input = std::io::BufReader::new(std::fs::File::open(path.clone())?);
 
-        match get_dom(&mut input){
-            Ok(dom)=>{
-                let object_refs = get_mesh_refs(&dom);
-                for &object_ref in object_refs.iter() {
-                    if let Some(object)=dom.get_by_ref(object_ref){
-                        if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("MeshId") {
-                            println!("Mesh content:{:?}",content);
-                            if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
-                                mesh_list.insert(asset_id.0);
-                            }
-                        }
-                    }
-                }
-            },
-            Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
-        }
-    }
-    println!("Mesh list:{:?}",mesh_list);
-    let processes_result:Result<Vec<_>, _>=mesh_list.iter().map(|asset_id|{
-        std::process::Command::new("wget")
-        .args(shared_args)
-        .arg(format!("meshes/unprocessed/{}",asset_id))
-        .arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
-        .spawn()
-    }).collect();
-    //naively wait for all because idk how to make an async progress bar lmao
-    for child in processes_result?{
-        let output=child.wait_with_output()?;
-        println!("Mesh exit_success:{}",output.status.success());
-    }
-    Ok(())
+		match get_dom(&mut input){
+			Ok(dom)=>{
+				let object_refs = get_mesh_refs(&dom);
+				for &object_ref in object_refs.iter() {
+					if let Some(object)=dom.get_by_ref(object_ref){
+						if let Some(rbx_dom_weak::types::Variant::Content(content)) = object.properties.get("MeshId") {
+							println!("Mesh content:{:?}",content);
+							if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
+								mesh_list.insert(asset_id.0);
+							}
+						}
+					}
+				}
+			},
+			Err(e)=>println!("error loading map {:?}: {:?}",path.file_name(),e),
+		}
+	}
+	println!("Mesh list:{:?}",mesh_list);
+	let processes_result:Result<Vec<_>, _>=mesh_list.iter().map(|asset_id|{
+		std::process::Command::new("wget")
+		.args(shared_args)
+		.arg(format!("meshes/unprocessed/{}",asset_id))
+		.arg(format!("https://assetdelivery.roblox.com/v1/asset/?ID={}",asset_id))
+		.spawn()
+	}).collect();
+	//naively wait for all because idk how to make an async progress bar lmao
+	for child in processes_result?{
+		let output=child.wait_with_output()?;
+		println!("Mesh exit_success:{}",output.status.success());
+	}
+	Ok(())
 }
 
 fn load_image<R:Read+Seek+std::io::BufRead>(input:&mut R)->AResult<image::DynamicImage>{
-    let mut fourcc=[0u8;4];
-    input.read_exact(&mut fourcc)?;
-    input.rewind()?;
-    match &fourcc{
-        b"\x89PNG"=>Ok(image::load(input,image::ImageFormat::Png)?),
-        b"\xFF\xD8\xFF\xE0"=>Ok(image::load(input,image::ImageFormat::Jpeg)?),//JFIF
-        b"<rob"=>Err(anyhow::Error::msg("Roblox xml garbage is not supported yet")),
-        other=>Err(anyhow::Error::msg(format!("Unknown texture format {:?}",other))),
-    }
+	let mut fourcc=[0u8;4];
+	input.read_exact(&mut fourcc)?;
+	input.rewind()?;
+	match &fourcc{
+		b"\x89PNG"=>Ok(image::load(input,image::ImageFormat::Png)?),
+		b"\xFF\xD8\xFF\xE0"=>Ok(image::load(input,image::ImageFormat::Jpeg)?),//JFIF
+		b"<rob"=>Err(anyhow::Error::msg("Roblox xml garbage is not supported yet")),
+		other=>Err(anyhow::Error::msg(format!("Unknown texture format {:?}",other))),
+	}
 }
 
 fn convert(file_thing:std::fs::DirEntry) -> AResult<()>{
-    let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+	let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
 
-    let mut extracted_input=None;
-    let image=match maybe_gzip_decode(&mut input){
-        Ok(ReaderType::GZip(mut readable)) => {
-            //gzip
-            let mut extracted:Vec<u8>=Vec::new();
-            //read the entire thing to the end so that I can clone the data and write a png to processed images
-            readable.read_to_end(&mut extracted)?;
-            extracted_input=Some(extracted.clone());
-            load_image(&mut std::io::Cursor::new(extracted))
-        },
-        Ok(ReaderType::Raw(readable)) => load_image(readable),
-        Err(e) => Err(e)?,
-    }?.to_rgba8();//this sets a=255, arcane is actually supposed to look like that
+	let mut extracted_input=None;
+	let image=match maybe_gzip_decode(&mut input){
+		Ok(ReaderType::GZip(mut readable)) => {
+			//gzip
+			let mut extracted:Vec<u8>=Vec::new();
+			//read the entire thing to the end so that I can clone the data and write a png to processed images
+			readable.read_to_end(&mut extracted)?;
+			extracted_input=Some(extracted.clone());
+			load_image(&mut std::io::Cursor::new(extracted))
+		},
+		Ok(ReaderType::Raw(readable)) => load_image(readable),
+		Err(e) => Err(e)?,
+	}?.to_rgba8();//this sets a=255, arcane is actually supposed to look like that
 
-    let format=if image.width()%4!=0||image.height()%4!=0{
-        image_dds::ImageFormat::R8G8B8A8Srgb
-    }else{
-        image_dds::ImageFormat::BC7Srgb
-    };
-    //this fails if the image dimensions are not a multiple of 4
-    let dds = image_dds::dds_from_image(
-        &image,
-        format,
-        image_dds::Quality::Slow,
-        image_dds::Mipmaps::GeneratedAutomatic,
-    )?;
+	let format=if image.width()%4!=0||image.height()%4!=0{
+		image_dds::ImageFormat::R8G8B8A8Srgb
+	}else{
+		image_dds::ImageFormat::BC7Srgb
+	};
+	//this fails if the image dimensions are not a multiple of 4
+	let dds = image_dds::dds_from_image(
+		&image,
+		format,
+		image_dds::Quality::Slow,
+		image_dds::Mipmaps::GeneratedAutomatic,
+	)?;
 
-    //write dds
-    let mut dest=std::path::PathBuf::from("textures/dds");
-    dest.push(file_thing.file_name());
-    dest.set_extension("dds");
-    let mut writer = std::io::BufWriter::new(std::fs::File::create(dest)?);
-    dds.write(&mut writer)?;
+	//write dds
+	let mut dest=std::path::PathBuf::from("textures/dds");
+	dest.push(file_thing.file_name());
+	dest.set_extension("dds");
+	let mut writer = std::io::BufWriter::new(std::fs::File::create(dest)?);
+	dds.write(&mut writer)?;
 
-    if let Some(mut extracted)=extracted_input{
-        //write extracted to processed
-        let mut dest=std::path::PathBuf::from("textures/processed");
-        dest.push(file_thing.file_name());
-        std::fs::write(dest, &mut extracted)?;
-        //delete ugly gzip file
-        std::fs::remove_file(file_thing.path())?;
-    }else{
-        //move file to processed
-        let mut dest=std::path::PathBuf::from("textures/processed");
-        dest.push(file_thing.file_name());
-        std::fs::rename(file_thing.path(), dest)?;
-    }
-    Ok(())
+	if let Some(mut extracted)=extracted_input{
+		//write extracted to processed
+		let mut dest=std::path::PathBuf::from("textures/processed");
+		dest.push(file_thing.file_name());
+		std::fs::write(dest, &mut extracted)?;
+		//delete ugly gzip file
+		std::fs::remove_file(file_thing.path())?;
+	}else{
+		//move file to processed
+		let mut dest=std::path::PathBuf::from("textures/processed");
+		dest.push(file_thing.file_name());
+		std::fs::rename(file_thing.path(), dest)?;
+	}
+	Ok(())
 }
 fn convert_textures() -> AResult<()>{
-    let start = std::time::Instant::now();
-    let mut threads=Vec::new();
-    for entry in std::fs::read_dir("textures/unprocessed")? {
-        let file_thing=entry?;
-        threads.push(std::thread::spawn(move ||{
-            let file_name=format!("{:?}",file_thing);
-            let result=convert(file_thing);
-            if let Err(e)=result{
-                println!("error processing file:{:?} error message:{:?}",file_name,e);
-            }
-        }));
-    }
-    let mut i=0;
-    let n_threads=threads.len();
-    for thread in threads{
-        i+=1;
-        if let Err(e)=thread.join(){
-            println!("thread error: {:?}",e);
-        }else{
-            println!("{}/{}",i,n_threads);
-        }
-    }
-    println!("{:?}", start.elapsed());
-    Ok(())
+	let start = std::time::Instant::now();
+	let mut threads=Vec::new();
+	for entry in std::fs::read_dir("textures/unprocessed")? {
+		let file_thing=entry?;
+		threads.push(std::thread::spawn(move ||{
+			let file_name=format!("{:?}",file_thing);
+			let result=convert(file_thing);
+			if let Err(e)=result{
+				println!("error processing file:{:?} error message:{:?}",file_name,e);
+			}
+		}));
+	}
+	let mut i=0;
+	let n_threads=threads.len();
+	for thread in threads{
+		i+=1;
+		if let Err(e)=thread.join(){
+			println!("thread error: {:?}",e);
+		}else{
+			println!("{}/{}",i,n_threads);
+		}
+	}
+	println!("{:?}", start.elapsed());
+	Ok(())
 }
 
 enum Scan{
-    Passed,
-    Blocked,
-    Flagged,
+	Passed,
+	Blocked,
+	Flagged,
 }
 
 fn scan() -> AResult<()>{
-    let mut id = get_id()?;
-    //Construct allowed scripts
-    let allowed_set = get_allowed_set()?;
-    let mut blocked = get_blocked()?;
+	let mut id = get_id()?;
+	//Construct allowed scripts
+	let allowed_set = get_allowed_set()?;
+	let mut blocked = get_blocked()?;
 
-    for entry in std::fs::read_dir("maps/unprocessed")? {
-        let file_thing=entry?;
-        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+	for entry in std::fs::read_dir("maps/unprocessed")? {
+		let file_thing=entry?;
+		let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
 
-        let dom = get_dom(&mut input)?;
+		let dom = get_dom(&mut input)?;
 
-        let script_refs = get_script_refs(&dom);
+		let script_refs = get_script_refs(&dom);
 
-        //check scribb
-        let mut fail_count=0;
-        let mut fail_type=Scan::Passed;
-        for &script_ref in script_refs.iter() {
-            if let Some(script)=dom.get_by_ref(script_ref){
-                if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
-                    //flag keywords and instantly fail
-                    if check_source_illegal_keywords(s){
-                        println!("{:?} - flagged.",file_thing.file_name());
-                        fail_type=Scan::Flagged;
-                        break;
-                    }
-                    if allowed_set.contains(s) {
-                        continue;
-                    }else{
-                        fail_type=Scan::Blocked;//no need to check for Flagged, it breaks the loop.
-                        fail_count+=1;
-                        if !blocked.contains(s) {
-                            blocked.insert(s.clone());//all fixed! just clone!
-                            std::fs::write(format!("scripts/blocked/{}.lua",id),s)?;
-                            id+=1;
-                        }
-                    }
-                }else{
-                    panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
-                }
-            }else{
-                panic!("FATAL: failed to get_by_ref {:?}",script_ref);
-            }
-        }
-        let mut dest=match fail_type {
-            Scan::Passed => std::path::PathBuf::from("maps/processed"),
-            Scan::Blocked => {
-                println!("{:?} - {} {} not allowed.",file_thing.file_name(),fail_count,if fail_count==1 {"script"}else{"scripts"});
-                std::path::PathBuf::from("maps/blocked")
-            }
-            Scan::Flagged => std::path::PathBuf::from("maps/flagged")
-        };
-        dest.push(file_thing.file_name());
-        std::fs::rename(file_thing.path(), dest)?;
-    }
-    std::fs::write("id",id.to_string())?;
-    Ok(())
+		//check scribb
+		let mut fail_count=0;
+		let mut fail_type=Scan::Passed;
+		for &script_ref in script_refs.iter() {
+			if let Some(script)=dom.get_by_ref(script_ref){
+				if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
+					//flag keywords and instantly fail
+					if check_source_illegal_keywords(s){
+						println!("{:?} - flagged.",file_thing.file_name());
+						fail_type=Scan::Flagged;
+						break;
+					}
+					if allowed_set.contains(s) {
+						continue;
+					}else{
+						fail_type=Scan::Blocked;//no need to check for Flagged, it breaks the loop.
+						fail_count+=1;
+						if !blocked.contains(s) {
+							blocked.insert(s.clone());//all fixed! just clone!
+							std::fs::write(format!("scripts/blocked/{}.lua",id),s)?;
+							id+=1;
+						}
+					}
+				}else{
+					panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
+				}
+			}else{
+				panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+			}
+		}
+		let mut dest=match fail_type {
+			Scan::Passed => std::path::PathBuf::from("maps/processed"),
+			Scan::Blocked => {
+				println!("{:?} - {} {} not allowed.",file_thing.file_name(),fail_count,if fail_count==1 {"script"}else{"scripts"});
+				std::path::PathBuf::from("maps/blocked")
+			}
+			Scan::Flagged => std::path::PathBuf::from("maps/flagged")
+		};
+		dest.push(file_thing.file_name());
+		std::fs::rename(file_thing.path(), dest)?;
+	}
+	std::fs::write("id",id.to_string())?;
+	Ok(())
 }
 
 fn extract(paths: Vec<std::path::PathBuf>) -> AResult<()>{
-    let mut id = 0;
-    //Construct allowed scripts
-    let mut script_set = std::collections::HashSet::<String>::new();
+	let mut id = 0;
+	//Construct allowed scripts
+	let mut script_set = std::collections::HashSet::<String>::new();
 
-    for path in paths {
-        let file_name=path.file_name();
-        let mut input = std::io::BufReader::new(std::fs::File::open(&path)?);
+	for path in paths {
+		let file_name=path.file_name();
+		let mut input = std::io::BufReader::new(std::fs::File::open(&path)?);
 
-        let dom = get_dom(&mut input)?;
+		let dom = get_dom(&mut input)?;
 
-        let script_refs = get_script_refs(&dom);
+		let script_refs = get_script_refs(&dom);
 
-        //extract scribb
-        for &script_ref in script_refs.iter() {
-            if let Some(script)=dom.get_by_ref(script_ref){
-                if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
-                    if script_set.contains(s) {
-                        continue;
-                    }else{
-                        script_set.insert(s.clone());
-                        std::fs::write(format!("scripts/extracted/{:?}_{}_{}.lua",file_name,id,script.name),s)?;
-                        id+=1;
-                    }
-                }else{
-                    panic!("FATAL: failed to get source for {:?}",file_name);
-                }
-            }else{
-                panic!("FATAL: failed to get_by_ref {:?}",script_ref);
-            }
-        }
-    }
-    println!("extracted {} {}",id,if id==1 {"script"}else{"scripts"});
-    Ok(())
+		//extract scribb
+		for &script_ref in script_refs.iter() {
+			if let Some(script)=dom.get_by_ref(script_ref){
+				if let Some(rbx_dom_weak::types::Variant::String(s)) = script.properties.get("Source") {
+					if script_set.contains(s) {
+						continue;
+					}else{
+						script_set.insert(s.clone());
+						std::fs::write(format!("scripts/extracted/{:?}_{}_{}.lua",file_name,id,script.name),s)?;
+						id+=1;
+					}
+				}else{
+					panic!("FATAL: failed to get source for {:?}",file_name);
+				}
+			}else{
+				panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+			}
+		}
+	}
+	println!("extracted {} {}",id,if id==1 {"script"}else{"scripts"});
+	Ok(())
 }
 fn replace() -> AResult<()>{
-    let allowed_map=get_allowed_map()?;
-    let replace_map=get_replace_map()?;
+	let allowed_map=get_allowed_map()?;
+	let replace_map=get_replace_map()?;
 
-    for entry in std::fs::read_dir("maps/blocked")? {
-        let file_thing=entry?;
+	for entry in std::fs::read_dir("maps/blocked")? {
+		let file_thing=entry?;
 
-        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
-        let mut dom = get_dom(&mut input)?;
+		let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+		let mut dom = get_dom(&mut input)?;
 
-        let script_refs = get_script_refs(&dom);
+		let script_refs = get_script_refs(&dom);
 
-        //check scribb
-        let mut any_failed=false;
-        for &script_ref in script_refs.iter() {
-            if let Some(script)=dom.get_by_ref(script_ref){
-                if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
-                    if let (Some(replace_id),Some(replace_script))=(replace_map.get(source),dom.get_by_ref_mut(script.referent())) {
-                        println!("replace {}",replace_id);
-                        //replace the source
-                        if let Some(replace_source)=allowed_map.get(replace_id){
-                            replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
-                        }else{
-                            println!("failed to get replacement source {}",replace_id);
-                            any_failed=true;
-                        }
-                    }else{
-                        println!("failed to failed to get replace_id and replace_script");
-                        any_failed=true;
-                    }
-                }else{
-                    panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
-                }
-            }else{
-                panic!("FATAL: failed to get_by_ref {:?}",script_ref);
-            }
-        }
-        if any_failed {
-            println!("One or more scripts failed to replace.");
-        }else{
-            let mut dest=std::path::PathBuf::from("maps/unprocessed");
-            dest.set_file_name(file_thing.file_name());
-            let output = std::io::BufWriter::new(std::fs::File::open(dest)?);
-            rbx_binary::to_writer(output, &dom, &[dom.root_ref()])?;
-        }
-    }
-    Ok(())
+		//check scribb
+		let mut any_failed=false;
+		for &script_ref in script_refs.iter() {
+			if let Some(script)=dom.get_by_ref(script_ref){
+				if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
+					if let (Some(replace_id),Some(replace_script))=(replace_map.get(source),dom.get_by_ref_mut(script.referent())) {
+						println!("replace {}",replace_id);
+						//replace the source
+						if let Some(replace_source)=allowed_map.get(replace_id){
+							replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
+						}else{
+							println!("failed to get replacement source {}",replace_id);
+							any_failed=true;
+						}
+					}else{
+						println!("failed to failed to get replace_id and replace_script");
+						any_failed=true;
+					}
+				}else{
+					panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
+				}
+			}else{
+				panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+			}
+		}
+		if any_failed {
+			println!("One or more scripts failed to replace.");
+		}else{
+			let mut dest=std::path::PathBuf::from("maps/unprocessed");
+			dest.set_file_name(file_thing.file_name());
+			let output = std::io::BufWriter::new(std::fs::File::open(dest)?);
+			rbx_binary::to_writer(output, &dom, &[dom.root_ref()])?;
+		}
+	}
+	Ok(())
 }
 
 enum UploadAction {
-    Upload(u64),
-    Skip,
-    New,
-    Delete,
+	Upload(u64),
+	Skip,
+	New,
+	Delete,
 }
 struct ParseUploadActionErr;
 impl std::str::FromStr for UploadAction {
-    type Err=ParseUploadActionErr;
-    fn from_str(s: &str) -> Result<Self, Self::Err>{
-        if s=="skip\n"{
-            Ok(Self::Skip)
-        }else if s=="new\n"{
-            Ok(Self::New)
-        }else if s=="delete\n"{
-            Ok(Self::Delete)
-        }else if let Ok(asset_id)=s[..s.len()-1].parse::<u64>(){
-            Ok(Self::Upload(asset_id))
-        }else{
-            Err(ParseUploadActionErr)
-        }
-    }
+	type Err=ParseUploadActionErr;
+	fn from_str(s: &str) -> Result<Self, Self::Err>{
+		if s=="skip\n"{
+			Ok(Self::Skip)
+		}else if s=="new\n"{
+			Ok(Self::New)
+		}else if s=="delete\n"{
+			Ok(Self::Delete)
+		}else if let Ok(asset_id)=s[..s.len()-1].parse::<u64>(){
+			Ok(Self::Upload(asset_id))
+		}else{
+			Err(ParseUploadActionErr)
+		}
+	}
 }
 
 fn upload() -> AResult<()>{
-    //interactive prompt per upload:
-    for entry in std::fs::read_dir("maps/passed")? {
-        let file_thing=entry?;
-        println!("map file: {:?}",file_thing.file_name());
-        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+	//interactive prompt per upload:
+	for entry in std::fs::read_dir("maps/passed")? {
+		let file_thing=entry?;
+		println!("map file: {:?}",file_thing.file_name());
+		let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
 
-        let dom = get_dom(&mut input)?;
-        let (modelname,creator,displayname) = get_mapinfo(&dom)?;
+		let dom = get_dom(&mut input)?;
+		let (modelname,creator,displayname) = get_mapinfo(&dom)?;
 
-        //Creator: [auto fill creator]
-        //DisplayName: [auto fill DisplayName]
-        //id: ["New" for blank because of my double enter key]
-        print!("Model name: {}\nCreator: {}\nDisplayName: {}\nAction or Upload Asset Id: ",modelname,creator,displayname);
-        std::io::Write::flush(&mut std::io::stdout())?;
-        let upload_action;
-        loop{
-            let mut upload_action_string = String::new();
-            std::io::stdin().read_line(&mut upload_action_string)?;
-            if let Ok(parsed_upload_action)=upload_action_string.parse::<UploadAction>(){
-                upload_action=parsed_upload_action;
-                break;
-            }else{
-                print!("Action or Upload Asset Id: ");
-                std::io::Write::flush(&mut std::io::stdout())?;
-            }
-        }
-        match upload_action {
-            UploadAction::Upload(asset_id) => {
-                let status=std::process::Command::new("../rbxcompiler-linux-amd64")
-                .arg("--compile=false")
-                .arg("--group=6980477")
-                .arg(format!("--asset={}",asset_id))
-                .arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
-                .status()?;
-                match status.code() {
-                    Some(0)=>{
-                        //move file
-                        let mut dest=std::path::PathBuf::from("maps/uploaded");
-                        dest.push(file_thing.file_name());
-                        std::fs::rename(file_thing.path(), dest)?;
-                    }
-                    Some(code)=>println!("upload failed! code={}",code),
-                    None => println!("no status code!"),
-                }
-            }
-            UploadAction::Skip => continue,
-            UploadAction::New => {
-                let output=std::process::Command::new("../rbxcompiler-linux-amd64")
-                .arg("--compile=false")
-                .arg("--group=6980477")
-                .arg("--new-asset=true")
-                .arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
-                .output()?;
-                match output.status.code() {
-                    Some(0)=>{
-                        //print output
-                        println!("{}", std::str::from_utf8(output.stdout.as_slice())?);
-                        //move file
-                        let mut dest=std::path::PathBuf::from("maps/uploaded");
-                        dest.push(file_thing.file_name());
-                        std::fs::rename(file_thing.path(), dest)?;
-                    }
-                    Some(code)=>println!("upload failed! code={}",code),
-                    None => println!("no status code!"),
-                }
-            }
-            UploadAction::Delete => std::fs::remove_file(file_thing.path())?,
-        }
-    }
-    Ok(())
+		//Creator: [auto fill creator]
+		//DisplayName: [auto fill DisplayName]
+		//id: ["New" for blank because of my double enter key]
+		print!("Model name: {}\nCreator: {}\nDisplayName: {}\nAction or Upload Asset Id: ",modelname,creator,displayname);
+		std::io::Write::flush(&mut std::io::stdout())?;
+		let upload_action;
+		loop{
+			let mut upload_action_string = String::new();
+			std::io::stdin().read_line(&mut upload_action_string)?;
+			if let Ok(parsed_upload_action)=upload_action_string.parse::<UploadAction>(){
+				upload_action=parsed_upload_action;
+				break;
+			}else{
+				print!("Action or Upload Asset Id: ");
+				std::io::Write::flush(&mut std::io::stdout())?;
+			}
+		}
+		match upload_action {
+			UploadAction::Upload(asset_id) => {
+				let status=std::process::Command::new("../rbxcompiler-linux-amd64")
+				.arg("--compile=false")
+				.arg("--group=6980477")
+				.arg(format!("--asset={}",asset_id))
+				.arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
+				.status()?;
+				match status.code() {
+					Some(0)=>{
+						//move file
+						let mut dest=std::path::PathBuf::from("maps/uploaded");
+						dest.push(file_thing.file_name());
+						std::fs::rename(file_thing.path(), dest)?;
+					}
+					Some(code)=>println!("upload failed! code={}",code),
+					None => println!("no status code!"),
+				}
+			}
+			UploadAction::Skip => continue,
+			UploadAction::New => {
+				let output=std::process::Command::new("../rbxcompiler-linux-amd64")
+				.arg("--compile=false")
+				.arg("--group=6980477")
+				.arg("--new-asset=true")
+				.arg(format!("--input={}",file_thing.path().into_os_string().into_string().unwrap()))
+				.output()?;
+				match output.status.code() {
+					Some(0)=>{
+						//print output
+						println!("{}", std::str::from_utf8(output.stdout.as_slice())?);
+						//move file
+						let mut dest=std::path::PathBuf::from("maps/uploaded");
+						dest.push(file_thing.file_name());
+						std::fs::rename(file_thing.path(), dest)?;
+					}
+					Some(code)=>println!("upload failed! code={}",code),
+					None => println!("no status code!"),
+				}
+			}
+			UploadAction::Delete => std::fs::remove_file(file_thing.path())?,
+		}
+	}
+	Ok(())
 }
 
 enum Interactive{
-    Passed,
-    Blocked,
-    Flagged,
+	Passed,
+	Blocked,
+	Flagged,
 }
 enum ScriptAction {
-    Pass,
-    Replace(u32),
-    Flag,
-    Block,
-    Delete,
+	Pass,
+	Replace(u32),
+	Flag,
+	Block,
+	Delete,
 }
 enum ScriptActionParseResult {
-    Pass,
-    Block,
-    Exit,
-    Delete,
+	Pass,
+	Block,
+	Exit,
+	Delete,
 }
 struct ParseScriptActionErr;
 impl std::str::FromStr for ScriptActionParseResult {
-    type Err=ParseScriptActionErr;
-    fn from_str(s: &str) -> Result<Self, Self::Err>{
-        if s=="pass\n"||s=="1\n"{
-            Ok(Self::Pass)
-        }else if s=="block\n"{
-            Ok(Self::Block)
-        }else if s=="exit\n"{
-            Ok(Self::Exit)
-        }else if s=="delete\n"{
-            Ok(Self::Delete)
-        }else{
-            Err(ParseScriptActionErr)
-        }
-    }
+	type Err=ParseScriptActionErr;
+	fn from_str(s: &str) -> Result<Self, Self::Err>{
+		if s=="pass\n"||s=="1\n"{
+			Ok(Self::Pass)
+		}else if s=="block\n"{
+			Ok(Self::Block)
+		}else if s=="exit\n"{
+			Ok(Self::Exit)
+		}else if s=="delete\n"{
+			Ok(Self::Delete)
+		}else{
+			Err(ParseScriptActionErr)
+		}
+	}
 }
 
 fn interactive() -> AResult<()>{
-    let mut id=get_id()?;
-    //Construct allowed scripts
-    let mut allowed_set=get_allowed_set()?;
-    let mut allowed_map=get_allowed_map()?;
-    let mut replace_map=get_replace_map()?;
-    let mut blocked = get_blocked()?;
+	let mut id=get_id()?;
+	//Construct allowed scripts
+	let mut allowed_set=get_allowed_set()?;
+	let mut allowed_map=get_allowed_map()?;
+	let mut replace_map=get_replace_map()?;
+	let mut blocked = get_blocked()?;
 
-    'map_loop: for entry in std::fs::read_dir("maps/unprocessed")? {
-        let file_thing=entry?;
-        println!("processing map={:?}",file_thing.file_name());
-        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
-        let mut dom = get_dom(&mut input)?;
+	'map_loop: for entry in std::fs::read_dir("maps/unprocessed")? {
+		let file_thing=entry?;
+		println!("processing map={:?}",file_thing.file_name());
+		let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+		let mut dom = get_dom(&mut input)?;
 
-        let script_refs = get_script_refs(&dom);
+		let script_refs = get_script_refs(&dom);
 
-        //check scribb
-        let mut script_count=0;
-        let mut replace_count=0;
-        let mut block_count=0;
-        let mut fail_type=Interactive::Passed;
-        for &script_ref in script_refs.iter() {
-            if let Some(script)=dom.get_by_ref(script_ref){
-                if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
-                    script_count+=1;
-                    let source_action=if check_source_illegal_keywords(source) {
-                        ScriptAction::Flag//script triggers flagging -> Flag
-                    } else if blocked.contains(source) {
-                        ScriptAction::Block//script is blocked -> Block
-                    } else if allowed_set.contains(source) {
-                        ScriptAction::Pass//script is allowed -> Pass
-                    }else if let Some(replace_id)=replace_map.get(source) {
-                        ScriptAction::Replace(*replace_id)
-                    }else{
-                        //interactive logic goes here
-                        print!("unresolved source location={}\naction: ",get_full_name(&dom, script));
-                        std::io::Write::flush(&mut std::io::stdout())?;
-                        //load source into current.lua
-                        std::fs::write("current.lua",source)?;
-                        //prompt action in terminal
-                        //wait for input
-                        let script_action;
-                        loop{
-                            let mut action_string = String::new();
-                            std::io::stdin().read_line(&mut action_string)?;
-                            if let Ok(parsed_script_action)=action_string.parse::<ScriptActionParseResult>(){
-                                script_action=parsed_script_action;
-                                break;
-                            }else{
-                                print!("action: ");
-                                std::io::Write::flush(&mut std::io::stdout())?;
-                            }
-                        }
-                        //update allowed/replace/blocked
-                        match script_action{
-                            ScriptActionParseResult::Pass => {
-                                //if current.lua was updated, create an allowed and replace file and set script_action to replace(new_id)
-                                let modified_source=std::fs::read_to_string("current.lua")?;
-                                if &modified_source==source{
-                                    //it's always new.
-                                    //insert allowed_set
-                                    allowed_set.insert(modified_source.clone());
-                                    //insert allowed_map
-                                    allowed_map.insert(id,modified_source.clone());
-                                    //write allowed/id.lua
-                                    std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
-                                    id+=1;
-                                    ScriptAction::Pass
-                                }else{
-                                    //insert allowed_set
-                                    allowed_set.insert(modified_source.clone());
-                                    //insert allowed_map
-                                    allowed_map.insert(id,modified_source.clone());
-                                    //insert replace_map
-                                    replace_map.insert(source.clone(),id);//this cannot be reached if it already exists
-                                    //write allowed/id.lua
-                                    std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
-                                    //write replace/id.lua
-                                    std::fs::write(format!("scripts/replace/{}.lua",id),source)?;
-                                    let ret=ScriptAction::Replace(id);
-                                    id+=1;
-                                    ret
-                                }
-                            },
-                            ScriptActionParseResult::Block => {
-                                blocked.insert(source.clone());
-                                std::fs::write(format!("scripts/blocked/{}.lua",id),source)?;
-                                id+=1;
-                                ScriptAction::Block
-                            },
-                            ScriptActionParseResult::Exit => break 'map_loop,
-                            ScriptActionParseResult::Delete => ScriptAction::Delete,
-                        }
-                    };
-                    
-                    let location=get_full_name(&dom, script);
-                    match source_action{
-                        ScriptAction::Pass => println!("passed source location={}",location),
-                        ScriptAction::Replace(replace_id)=>{
-                            //replace the source
-                            if let (Some(replace_source),Some(replace_script))=(allowed_map.get(&replace_id),dom.get_by_ref_mut(script.referent())){
-                                replace_count+=1;
-                                println!("replaced source id={} location={}",replace_id,location);
-                                replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
-                            }else{
-                                panic!("failed to get replacement source id={} location={}",replace_id,location);
-                            }
-                        },
-                        ScriptAction::Delete => {
-                            println!("deleted source location={}",location);
-                            replace_count+=1;//trigger a new file generation
-                            dom.destroy(script.referent());
-                        },
-                        ScriptAction::Flag => {
-                            println!("flagged source location={}",location);
-                            fail_type=Interactive::Flagged;
-                        },
-                        ScriptAction::Block => {
-                            block_count+=1;
-                            println!("blocked source location={}",location);
-                            match fail_type{
-                                Interactive::Passed => fail_type=Interactive::Blocked,
-                                _=>(),
-                            }
-                        },
-                    }
-                }else{
-                    panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
-                }
-            }else{
-                panic!("FATAL: failed to get_by_ref {:?}",script_ref);
-            }
-        }
-        let mut dest=match fail_type{
-            Interactive::Passed => {
-                println!("map={:?} passed with {} {}",file_thing.file_name(),script_count,if script_count==1 {"script"}else{"scripts"});
-                if replace_count==0{
-                    std::path::PathBuf::from("maps/passed")
-                }else{
-                    //create new file
-                    println!("{} {} replaced - generating new file...",replace_count,if replace_count==1 {"script was"}else{"scripts were"});
-                    let mut dest=std::path::PathBuf::from("maps/passed");
-                    dest.push(file_thing.file_name());
-                    let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
-                    //write workspace:GetChildren()[1]
-                    let workspace_children=dom.root().children();
-                    if workspace_children.len()!=1{
-                        return Err(anyhow::Error::msg("there can only be one model"));
-                    }
-                    rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
-                    //move original to processed folder
-                    std::path::PathBuf::from("maps/unaltered")
-                }
-            },//write map into maps/processed
-            Interactive::Blocked => {
-                println!("map={:?} blocked with {}/{} {} blocked",file_thing.file_name(),block_count,script_count,if script_count==1 {"script"}else{"scripts"});
-                std::path::PathBuf::from("maps/blocked")
-            },//write map into maps/blocked
-            Interactive::Flagged => {
-                println!("map={:?} flagged",file_thing.file_name());
-                std::path::PathBuf::from("maps/flagged")
-            },//write map into maps/flagged
-        };
-        dest.push(file_thing.file_name());
-        std::fs::rename(file_thing.path(), dest)?;
-    }
-    std::fs::write("id",id.to_string())?;
-    Ok(())
+		//check scribb
+		let mut script_count=0;
+		let mut replace_count=0;
+		let mut block_count=0;
+		let mut fail_type=Interactive::Passed;
+		for &script_ref in script_refs.iter() {
+			if let Some(script)=dom.get_by_ref(script_ref){
+				if let Some(rbx_dom_weak::types::Variant::String(source)) = script.properties.get("Source") {
+					script_count+=1;
+					let source_action=if check_source_illegal_keywords(source) {
+						ScriptAction::Flag//script triggers flagging -> Flag
+					} else if blocked.contains(source) {
+						ScriptAction::Block//script is blocked -> Block
+					} else if allowed_set.contains(source) {
+						ScriptAction::Pass//script is allowed -> Pass
+					}else if let Some(replace_id)=replace_map.get(source) {
+						ScriptAction::Replace(*replace_id)
+					}else{
+						//interactive logic goes here
+						print!("unresolved source location={}\naction: ",get_full_name(&dom, script));
+						std::io::Write::flush(&mut std::io::stdout())?;
+						//load source into current.lua
+						std::fs::write("current.lua",source)?;
+						//prompt action in terminal
+						//wait for input
+						let script_action;
+						loop{
+							let mut action_string = String::new();
+							std::io::stdin().read_line(&mut action_string)?;
+							if let Ok(parsed_script_action)=action_string.parse::<ScriptActionParseResult>(){
+								script_action=parsed_script_action;
+								break;
+							}else{
+								print!("action: ");
+								std::io::Write::flush(&mut std::io::stdout())?;
+							}
+						}
+						//update allowed/replace/blocked
+						match script_action{
+							ScriptActionParseResult::Pass => {
+								//if current.lua was updated, create an allowed and replace file and set script_action to replace(new_id)
+								let modified_source=std::fs::read_to_string("current.lua")?;
+								if &modified_source==source{
+									//it's always new.
+									//insert allowed_set
+									allowed_set.insert(modified_source.clone());
+									//insert allowed_map
+									allowed_map.insert(id,modified_source.clone());
+									//write allowed/id.lua
+									std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
+									id+=1;
+									ScriptAction::Pass
+								}else{
+									//insert allowed_set
+									allowed_set.insert(modified_source.clone());
+									//insert allowed_map
+									allowed_map.insert(id,modified_source.clone());
+									//insert replace_map
+									replace_map.insert(source.clone(),id);//this cannot be reached if it already exists
+									//write allowed/id.lua
+									std::fs::write(format!("scripts/allowed/{}.lua",id),modified_source)?;
+									//write replace/id.lua
+									std::fs::write(format!("scripts/replace/{}.lua",id),source)?;
+									let ret=ScriptAction::Replace(id);
+									id+=1;
+									ret
+								}
+							},
+							ScriptActionParseResult::Block => {
+								blocked.insert(source.clone());
+								std::fs::write(format!("scripts/blocked/{}.lua",id),source)?;
+								id+=1;
+								ScriptAction::Block
+							},
+							ScriptActionParseResult::Exit => break 'map_loop,
+							ScriptActionParseResult::Delete => ScriptAction::Delete,
+						}
+					};
+					
+					let location=get_full_name(&dom, script);
+					match source_action{
+						ScriptAction::Pass => println!("passed source location={}",location),
+						ScriptAction::Replace(replace_id)=>{
+							//replace the source
+							if let (Some(replace_source),Some(replace_script))=(allowed_map.get(&replace_id),dom.get_by_ref_mut(script.referent())){
+								replace_count+=1;
+								println!("replaced source id={} location={}",replace_id,location);
+								replace_script.properties.insert("Source".to_string(), rbx_dom_weak::types::Variant::String(replace_source.clone()));
+							}else{
+								panic!("failed to get replacement source id={} location={}",replace_id,location);
+							}
+						},
+						ScriptAction::Delete => {
+							println!("deleted source location={}",location);
+							replace_count+=1;//trigger a new file generation
+							dom.destroy(script.referent());
+						},
+						ScriptAction::Flag => {
+							println!("flagged source location={}",location);
+							fail_type=Interactive::Flagged;
+						},
+						ScriptAction::Block => {
+							block_count+=1;
+							println!("blocked source location={}",location);
+							match fail_type{
+								Interactive::Passed => fail_type=Interactive::Blocked,
+								_=>(),
+							}
+						},
+					}
+				}else{
+					panic!("FATAL: failed to get source for {:?}",file_thing.file_name());
+				}
+			}else{
+				panic!("FATAL: failed to get_by_ref {:?}",script_ref);
+			}
+		}
+		let mut dest=match fail_type{
+			Interactive::Passed => {
+				println!("map={:?} passed with {} {}",file_thing.file_name(),script_count,if script_count==1 {"script"}else{"scripts"});
+				if replace_count==0{
+					std::path::PathBuf::from("maps/passed")
+				}else{
+					//create new file
+					println!("{} {} replaced - generating new file...",replace_count,if replace_count==1 {"script was"}else{"scripts were"});
+					let mut dest=std::path::PathBuf::from("maps/passed");
+					dest.push(file_thing.file_name());
+					let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
+					//write workspace:GetChildren()[1]
+					let workspace_children=dom.root().children();
+					if workspace_children.len()!=1{
+						return Err(anyhow::Error::msg("there can only be one model"));
+					}
+					rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
+					//move original to processed folder
+					std::path::PathBuf::from("maps/unaltered")
+				}
+			},//write map into maps/processed
+			Interactive::Blocked => {
+				println!("map={:?} blocked with {}/{} {} blocked",file_thing.file_name(),block_count,script_count,if script_count==1 {"script"}else{"scripts"});
+				std::path::PathBuf::from("maps/blocked")
+			},//write map into maps/blocked
+			Interactive::Flagged => {
+				println!("map={:?} flagged",file_thing.file_name());
+				std::path::PathBuf::from("maps/flagged")
+			},//write map into maps/flagged
+		};
+		dest.push(file_thing.file_name());
+		std::fs::rename(file_thing.path(), dest)?;
+	}
+	std::fs::write("id",id.to_string())?;
+	Ok(())
 }
 
 
 fn unzip_all()->AResult<()>{
-    for entry in std::fs::read_dir("maps/unprocessed")? {
-        let file_thing=entry?;
-        println!("processing map={:?}",file_thing.file_name());
-        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
-        match maybe_gzip_decode(&mut input){
-        Ok(ReaderType::GZip(mut readable)) => {
-            //gzip
-            let mut extracted:Vec<u8>=Vec::new();
-            //read the entire thing to the end so that I can clone the data and write a png to processed images
-            readable.read_to_end(&mut extracted)?;
-            //write extracted
-            let mut dest=std::path::PathBuf::from("maps/unzipped");
-            dest.push(file_thing.file_name());
-            std::fs::write(dest, &mut extracted)?;
-            //delete ugly gzip file
-            std::fs::remove_file(file_thing.path())?;
-        },
-        Ok(ReaderType::Raw(_)) => (),
-        Err(e) => Err(e)?,
-        }
-    }
-    Ok(())
+	for entry in std::fs::read_dir("maps/unprocessed")? {
+		let file_thing=entry?;
+		println!("processing map={:?}",file_thing.file_name());
+		let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+		match maybe_gzip_decode(&mut input){
+		Ok(ReaderType::GZip(mut readable)) => {
+			//gzip
+			let mut extracted:Vec<u8>=Vec::new();
+			//read the entire thing to the end so that I can clone the data and write a png to processed images
+			readable.read_to_end(&mut extracted)?;
+			//write extracted
+			let mut dest=std::path::PathBuf::from("maps/unzipped");
+			dest.push(file_thing.file_name());
+			std::fs::write(dest, &mut extracted)?;
+			//delete ugly gzip file
+			std::fs::remove_file(file_thing.path())?;
+		},
+		Ok(ReaderType::Raw(_)) => (),
+		Err(e) => Err(e)?,
+		}
+	}
+	Ok(())
 }
 
 fn write_attributes() -> AResult<()>{
-    for entry in std::fs::read_dir("maps/unprocessed")? {
-        let file_thing=entry?;
-        println!("processing map={:?}",file_thing.file_name());
-        let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
-        let mut dom = get_dom(&mut input)?;
+	for entry in std::fs::read_dir("maps/unprocessed")? {
+		let file_thing=entry?;
+		println!("processing map={:?}",file_thing.file_name());
+		let mut input = std::io::BufReader::new(std::fs::File::open(file_thing.path())?);
+		let mut dom = get_dom(&mut input)?;
 
-        let button_refs = get_button_refs(&dom);
+		let button_refs = get_button_refs(&dom);
 
-        for &button_ref in &button_refs {
-            if let Some(button)=dom.get_by_ref_mut(button_ref){
-                match button.properties.get_mut("Attributes"){
-                    Some(rbx_dom_weak::types::Variant::Attributes(attributes))=>{
-                        println!("Appending Ref={} to existing attributes for {}",button_ref,button.name);
-                        attributes.insert("Ref".to_string(),rbx_dom_weak::types::Variant::String(button_ref.to_string()));
-                    },
-                    None=>{
-                        println!("Creating new attributes with Ref={} for {}",button_ref,button.name);
-                        let mut attributes=rbx_dom_weak::types::Attributes::new();
-                        attributes.insert("Ref".to_string(),rbx_dom_weak::types::Variant::String(button_ref.to_string()));
-                        button.properties.insert("Attributes".to_string(),rbx_dom_weak::types::Variant::Attributes(attributes));
-                    }
-                    _=>unreachable!("Fetching attributes did not return attributes."),
-                }
-            }
-        }
-        let mut dest={
-            let mut dest=std::path::PathBuf::from("maps/attributes");
-            dest.push(file_thing.file_name());
-            let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
-            //write workspace:GetChildren()[1]
-            let workspace_children=dom.root().children();
-            if workspace_children.len()!=1{
-                return Err(anyhow::Error::msg("there can only be one model"));
-            }
-            rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
-            //move original to processed folder
-            std::path::PathBuf::from("maps/unaltered")
-        };
-        dest.push(file_thing.file_name());
-        std::fs::rename(file_thing.path(), dest)?;
-    }
-    Ok(())
+		for &button_ref in &button_refs {
+			if let Some(button)=dom.get_by_ref_mut(button_ref){
+				match button.properties.get_mut("Attributes"){
+					Some(rbx_dom_weak::types::Variant::Attributes(attributes))=>{
+						println!("Appending Ref={} to existing attributes for {}",button_ref,button.name);
+						attributes.insert("Ref".to_string(),rbx_dom_weak::types::Variant::String(button_ref.to_string()));
+					},
+					None=>{
+						println!("Creating new attributes with Ref={} for {}",button_ref,button.name);
+						let mut attributes=rbx_dom_weak::types::Attributes::new();
+						attributes.insert("Ref".to_string(),rbx_dom_weak::types::Variant::String(button_ref.to_string()));
+						button.properties.insert("Attributes".to_string(),rbx_dom_weak::types::Variant::Attributes(attributes));
+					}
+					_=>unreachable!("Fetching attributes did not return attributes."),
+				}
+			}
+		}
+		let mut dest={
+			let mut dest=std::path::PathBuf::from("maps/attributes");
+			dest.push(file_thing.file_name());
+			let output = std::io::BufWriter::new(std::fs::File::create(dest)?);
+			//write workspace:GetChildren()[1]
+			let workspace_children=dom.root().children();
+			if workspace_children.len()!=1{
+				return Err(anyhow::Error::msg("there can only be one model"));
+			}
+			rbx_binary::to_writer(output, &dom, &[workspace_children[0]])?;
+			//move original to processed folder
+			std::path::PathBuf::from("maps/unaltered")
+		};
+		dest.push(file_thing.file_name());
+		std::fs::rename(file_thing.path(), dest)?;
+	}
+	Ok(())
 }
 
 fn main() -> AResult<()> {
-    let cli = Cli::parse();
-    match cli.command {
-        Commands::Download(map_list)=>download(map_list.maps),
-        Commands::DownloadTextures(pathlist)=>download_textures(pathlist.paths),
-        Commands::ConvertTextures=>convert_textures(),
-        Commands::DownloadMeshes(pathlist)=>download_meshes(pathlist.paths),
-        Commands::Extract(pathlist)=>extract(pathlist.paths),
-        Commands::WriteAttributes=>write_attributes(),
-        Commands::Interactive=>interactive(),
-        Commands::Replace=>replace(),
-        Commands::Scan=>scan(),
-        Commands::UnzipAll=>unzip_all(),
-        Commands::Upload=>upload(),
-    }
+	let cli = Cli::parse();
+	match cli.command {
+		Commands::Download(map_list)=>download(map_list.maps),
+		Commands::DownloadTextures(pathlist)=>download_textures(pathlist.paths),
+		Commands::ConvertTextures=>convert_textures(),
+		Commands::DownloadMeshes(pathlist)=>download_meshes(pathlist.paths),
+		Commands::Extract(pathlist)=>extract(pathlist.paths),
+		Commands::WriteAttributes=>write_attributes(),
+		Commands::Interactive=>interactive(),
+		Commands::Replace=>replace(),
+		Commands::Scan=>scan(),
+		Commands::UnzipAll=>unzip_all(),
+		Commands::Upload=>upload(),
+	}
 }