lngcnv 1.7.0

// LNGCNV VERSION 1.7.0 / MIT LICENSE © 2022 PIOTR BAJDEK

// MODULE MODSPA

// CLIPPY LINTS

#![deny(clippy::no_effect_replace)]
#![warn(clippy::nursery, clippy::pedantic)]
#![allow(clippy::similar_names, clippy::too_many_lines, clippy::unicode_not_nfc)]
#![allow(clippy::string_lit_as_bytes)]

// IMPORTS

use std::fs::OpenOptions;
use std::io::Write;

// SIMPLIFY INTERPUNCTION

fn spapncbeg(lowercase: &str) -> String {
    let pncbeg = &lowercase
        .replace([';', '!', '?', '¡', '¿'], ".")
        .replace(").", ".")
        .replace("),", ",")
        .replace(" «", ", ")
        .replace(".«", "")
        .replace("».", ".")
        .replace([')', ':', '»'], ",")
        .replace("--", " – ")
        .replace('(', "∣ .")
        .replace(' ', "# #")
        .replace('.', "#.#")
        .replace(',', "#,#");
    pncbeg.to_string()
}

// REMOVE INTERPUNCTION

fn spapncend(strmod: &str) -> String {
    let result = &strmod
        .replace("# #", " ")
        .replace("#.#", ".")
        .replace("#,#", ",")
        .replace(',', " ∣")
        .replace(". ", " ∥ ")
        .replace('.', "")
        .replace(" - ", " ∣ ")
        .replace(" – ", " ∣ ")
        .replace("∣ ∣", "∣")
        .replace("∣ ∥", "∥");
    result.to_string()
}

// SPECIAL WORDS

fn spapalesp(pncbeg: &str) -> String {
    let palesp = &pncbeg.replace("mexic", "mejic").replace("méxic", "méjic").replace("ximena", "jimena").replace("ximénez", "jiménez");
    palesp.to_string()
}

// WORD STRESS: VOWEL "A"

fn spaaccent_a(palesp: &str) -> String {
    let spaacc_a = &palesp
        .replace("ar#", "ár#")
        .replace("arme#", "árme#")
        .replace("arte#", "árte#")
        .replace("arse#", "árse#")
        .replace("arnos#", "árnos#")
        .replace("arla", "árla")
        .replace("arlo", "árlo")
        .replace("arle", "árle")
        .replace("ando#", "ándo#")
        .replace("aba#", "ába#")
        .replace("aban#", "ában#")
        .replace("abas#", "ábas#")
        .replace("acha#", "ácha#")
        .replace("acho", "ácho")
        .replace("ada#", "áda#")
        .replace("adas", "ádas")
        .replace("ado#", "ádo#")
        .replace("ados", "ádos")
        .replace("adre#", "ádre#")
        .replace("adres#", "ádres#")
        .replace("ante#", "ánte#")
        .replace("antes", "ántes")
        .replace("aste#", "áste#")
        .replace("ad#", "ád#")
        .replace("al#", "ál#")
        .replace("ales", "áles")
        .replace("ambre", "ámbre")
        .replace("ano#", "áno#")
        .replace("anos#", "ános#")
        .replace("ano", "áno")
        .replace("éáno", "éano")
        .replace("átáno", "átano")
        .replace("ana#", "ána#")
        .replace("anas#", "ánas#")
        .replace("ábána", "ábana")
        .replace("año#", "áño#")
        .replace("años#", "áños#")
        .replace("aña#", "áña#")
        .replace("añas#", "áñas#")
        .replace("amos#", "ámos#")
        .replace("íámos", "íamos")
        .replace("aque#", "áque#")
        .replace("aques#", "áques#")
        .replace("ara#", "ára#")
        .replace("aras#", "áras#")
        .replace("aro#", "áro#")
        .replace("aros#", "áros#")
        .replace("arra#", "árra#")
        .replace("arras#", "árras#")
        .replace("arro#", "árro#")
        .replace("arros#", "árros#")
        .replace("ántáro", "ántaro")
        .replace("aria", "ária")
        .replace("ario", "ário")
        .replace("aron#", "áron#")
        .replace("argo", "árgo")
        .replace("argos", "árgos")
        .replace("arga#", "árga#")
        .replace("argas#", "árgas#")
        .replace("asa#", "ása#")
        .replace("ata#", "áta#")
        .replace("atas#", "átas#")
        .replace("atro#", "átro#")
        .replace("ato#", "áto#")
        .replace("atos#", "átos#")
        .replace("alma#", "álma#")
        .replace("almas#", "álmas#")
        .replace("anja", "ánja")
        .replace("ánjar", "anjar")
        .replace("ánjad", "anjad")
        .replace("alda", "álda")
        .replace("áldad", "aldad")
        .replace("áldar", "aldar");
    spaacc_a.to_string()
}

// WORD STRESS: VOWEL "E"

fn spaaccent_e(spaacc_a: &str) -> String {
    let spaacc_e = &spaacc_a
        .replace("er#", "ér#")
        .replace("étér", "éter")
        .replace("erme#", "érme#")
        .replace("erte#", "érte#")
        .replace("erse#", "érse#")
        .replace("ernos#", "érnos#")
        .replace("erla", "érla")
        .replace("erlo", "érlo")
        .replace("erle", "érle")
        .replace("iendo", "iéndo")
        .replace("ecto#", "écto#")
        .replace("ectos#", "éctos#")
        .replace("ecta#", "écta#")
        .replace("ectas#", "éctas#")
        .replace("encio#", "éncio#")
        .replace("encia#", "éncia#")
        .replace("encias#", "éncias#")
        .replace("ejo#", "éjo#")
        .replace("ejos#", "éjos#")
        .replace("eja#", "éja#")
        .replace("ejas#", "éjas#")
        .replace("ente#", "énte#")
        .replace("entes", "éntes")
        .replace("enso#", "énso#")
        .replace("ensos", "énsos")
        .replace("ento#", "énto#")
        .replace("entos#", "éntos#")
        .replace("ero#", "éro#")
        .replace("eros#", "éros#")
        .replace("eron", "éron")
        .replace("era#", "éra#")
        .replace("eras#", "éras#")
        .replace("íscér", "íscer")
        .replace("íspér", "ísper")
        .replace("esca#", "ésca#")
        .replace("esco#", "ésco#")
        .replace("esta#", "ésta#")
        .replace("estas#", "éstas#")
        .replace("esto#", "ésto#")
        .replace("estos#", "éstos#")
        .replace("ella", "élla")
        .replace("ello", "éllo")
        .replace("uela", "uéla")
        .replace("uelo", "uélo")
        .replace("eña#", "éña#")
        .replace("eñas#", "éñas#")
        .replace("eño#", "éño#")
        .replace("eños#", "éños#")
        .replace("ensa#", "énsa#")
        .replace("ensas#", "énsas#")
        .replace("enso#", "énso#")
        .replace("ensos#", "énsos#")
        .replace("eno#", "éno#")
        .replace("enos#", "énos#")
        .replace("desde#", "désde#")
        .replace("iempo", "iémpo")
        .replace("eces#", "éces#")
        .replace("ea#", "éa#")
        .replace("eas#", "éas#")
        .replace("ídéa", "ídea")
        .replace("ínéa", "ínea")
        .replace("eo#", "éo#")
        .replace("eos#", "éos#")
        .replace("ánéo", "áneo")
        .replace("ópéo", "ópeo")
        .replace("eza#", "éza#")
        .replace("ezas#", "ézas#")
        .replace("iet", "iét")
        .replace("iétád", "ietád")
        .replace("que", "qu^e")
        .replace("gue", "gu^e")
        .replace("ue", "ué")
        .replace("qu^e", "que")
        .replace("gu^e", "gue")
        .replace("úedá", "uedá")
        .replace("úedó", "uedó")
        .replace("uérí", "uerí")
        .replace("elio", "élio");
    spaacc_e.to_string()
}

// WORD STRESS: VOWEL "O"

fn spaaccent_o(spaacc_e: &str) -> String {
    let spaacc_o = &spaacc_e
        .replace("ol#", "ól#")
        .replace("oles", "óles")
        .replace("odo#", "ódo#")
        .replace("odos#", "ódos#")
        .replace("ómódo", "ómodo")
        .replace("ojo#", "ójo#")
        .replace("ojos#", "ójos#")
        .replace("oja#", "ója#")
        .replace("ojas#", "ójas#")
        .replace("oma#", "óma#")
        .replace("omas#", "ómas#")
        .replace("omo#", "ómo#")
        .replace("omos#", "ómos#")
        .replace("one#", "óne#")
        .replace("ones#", "ónes#")
        .replace("or#", "ór#")
        .replace("ores#", "óres#")
        .replace("onda#", "ónda#")
        .replace("ondas#", "óndas#")
        .replace("ondo#", "óndo#")
        .replace("ondos#", "óndos#")
        .replace("ora#", "óra#")
        .replace("oras#", "óras#")
        .replace("oro#", "óro#")
        .replace("oros#", "óros#")
        .replace("orda#", "órda#")
        .replace("ordas#", "órdas#")
        .replace("ordo", "órdo")
        .replace("orta#", "órta#")
        .replace("ortas#", "órtas#")
        .replace("ortan#", "órtan#")
        .replace("orso", "órso")
        .replace("oso", "óso")
        .replace("osos", "ósos")
        .replace("ósot", "osót")
        .replace("osa#", "ósa#")
        .replace("osas", "ósas")
        .replace("otro", "ótro")
        .replace("opa#", "ópa#")
        .replace("porque#", "pórque#")
        .replace("solo", "sólo")
        .replace("sola#", "sóla#")
        .replace("solas", "sólas")
        .replace("oble#", "óble#")
        .replace("obles#", "óble#")
        .replace("ozc", "ózc")
        .replace("osco#", "ósco#")
        .replace("oscos#", "óscos#")
        .replace("osca#", "ósca#")
        .replace("oscas#", "óscas#");
    spaacc_o.to_string()
}

// WORD STRESS: VOWEL "I"

fn spaaccent_i(spaacc_o: &str) -> String {
    let spaacc_i = &spaacc_o
        .replace("ir#", "ír#")
        .replace("irme#", "írme#")
        .replace("irte#", "írte#")
        .replace("irse#", "írse#")
        .replace("irnos#", "írnos#")
        .replace("irla", "írla")
        .replace("irlo", "írlo")
        .replace("irle", "írle")
        .replace("iz#", "íz#")
        .replace("ices#", "íces#")
        .replace("icio#", "ício#")
        .replace("icios#", "ícios#")
        .replace("ífíces", "ífices")
        .replace("álíces", "álices")
        .replace("ápíces", "ápices")
        .replace("ómplíces", "ómplices")
        .replace("ido#", "ído#")
        .replace("idos#", "ídos#")
        .replace("ida#", "ída#")
        .replace("idas#", "ídas#")
        .replace("álíd", "álid")
        .replace("ándíd", "ándid")
        .replace("ápíd", "ápid")
        .replace("éndíd", "éndid")
        .replace("érfíd", "érfid")
        .replace("ígíd", "ígid")
        .replace("ítíd", "ítid")
        .replace("útríd", "útrid")
        .replace("igo#", "ígo#")
        .replace("igos#", "ígos#")
        .replace("átígo", "átigo")
        .replace("ódígo", "ódigo")
        .replace("ito#", "íto#")
        .replace("itos#", "ítos#")
        .replace("ita#", "íta#")
        .replace("itas#", "ítas#")
        .replace("énít", "énit")
        .replace("érrít", "érrit")
        .replace("ácít", "ácit")
        .replace("ícít", "ícit")
        .replace("álpít", "álpit")
        .replace("ólít", "ólit")
        .replace("óndít", "óndit")
        .replace("ónít", "ónit")
        .replace("ósít", "ósit")
        .replace("ijo#", "íjo#")
        .replace("ijos#", "íjos#")
        .replace("ija#", "íja#")
        .replace("ijas#", "íjas#")
        .replace("illo#", "íllo#")
        .replace("illos#", "íllos#")
        .replace("illa#", "ílla#")
        .replace("illas#", "íllas#")
        .replace("iño#", "íño#")
        .replace("iños#", "íños#")
        .replace("iña#", "íña#")
        .replace("iñas#", "íñas#")
        .replace("ino#", "íno#")
        .replace("inos#", "ínos#")
        .replace("ina#", "ína#")
        .replace("inas#", "ínas#")
        .replace("ágína", "ágina")
        .replace("into#", "ínto#")
        .replace("intos#", "íntos#")
        .replace("inta#", "ínta#")
        .replace("intas#", "íntas#")
        .replace("ismo#", "ísmo#")
        .replace("ismos#", "ísmos#")
        .replace("isma#", "ísma#")
        .replace("ismas#", "ísmas#")
        .replace("iso#", "íso#")
        .replace("isos#", "ísos#")
        .replace("isa#", "ísa#")
        .replace("isas#", "ísas#")
        .replace("izo#", "ízo#")
        .replace("izos#", "ízos#")
        .replace("iza#", "íza#")
        .replace("izas#", "ízas#")
        .replace("isto#", "ísto#")
        .replace("istos#", "ístos#")
        .replace("ista#", "ísta#")
        .replace("istas#", "ístas#")
        .replace("imos", "ímos")
        .replace("ánímos", "ánimos")
        .replace("íntímos", "íntimos")
        .replace("ísímos", "ísimos")
        .replace("ójímos", "ójimos")
        .replace("últímos", "últimos");
    spaacc_i.to_string()
}

// WORD STRESS: VOWEL "U"

fn spaaccent_u(spaacc_i: &str) -> String {
    let spaacc_u = &spaacc_i
        .replace("udo#", "údo#")
        .replace("udos#", "údos#")
        .replace("uda#", "úda#")
        .replace("udas#", "údas#")
        .replace("uno#", "úno#")
        .replace("unos#", "únos#")
        .replace("una#", "úna#")
        .replace("unas#", "únas#")
        .replace("undo#", "úndo#")
        .replace("undos#", "úndos#")
        .replace("unda#", "únda#")
        .replace("undas#", "úndas#")
        .replace("unto#", "únto#")
        .replace("untos#", "úntos#")
        .replace("uso#", "úso#")
        .replace("usos#", "úsos#")
        .replace("usa#", "úsa#")
        .replace("usas#", "úsas#")
        .replace("usto#", "ústo#")
        .replace("ustos#", "ústos#")
        .replace("usta#", "ústa#")
        .replace("ustas#", "ústas#")
        .replace("uto#", "úto#")
        .replace("utos#", "útos#")
        .replace("uta#", "úta#")
        .replace("utas#", "útas#")
        .replace("ulto#", "últo#")
        .replace("ultos#", "últos#")
        .replace("ulta#", "últa#")
        .replace("ultas#", "últas#")
        .replace("uro#", "úro#")
        .replace("uros#", "úros#")
        .replace("ura#", "úra#")
        .replace("uras#", "úras#")
        .replace("uyo#", "úyo#")
        .replace("uyos#", "úyos#")
        .replace("uya#", "úya#")
        .replace("uyas#", "úyas#")
        .replace("ucho#", "úcho#")
        .replace("uchos#", "úchos#")
        .replace("ucha#", "úcha#")
        .replace("uchas#", "úchas#");
    spaacc_u.to_string()
}

//   ++++++++++   ++++++++++   ++++++++++

// BOGOTÁ: IPA

pub fn spacobogota(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);
    let spaacc_i = spaaccent_i(&spaacc_o);
    let spaacc_u = spaaccent_u(&spaacc_i);

    let strmod = &spaacc_u
        .replace("ch", "t͡ʃ")
        .replace("ce", "se")
        .replace("cé", "sé")
        .replace("ci", "si")
        .replace("cí", "sí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace("ké", "kɛ")
        .replace("ke", "kɛ")
        .replace("kó", "kɔ")
        .replace("ko", "kɔ")
        .replace('x', "ks")
        .replace('h', "")
        .replace('j', "h")
        .replace("ge", "he")
        .replace("gé", "hé")
        .replace("gi", "hi")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("y#", "i#")
        .replace('y', "ɟ͡ʝ")
        .replace("ll", "ɟ͡ʝ")
        .replace("lt͡ʃ", "lʲt͡ʃ")
        .replace("lt", "l̪t")
        .replace('b', "β")
        .replace("#β", "#b")
        .replace("mβ", "mb")
        .replace("lβ", "lb")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ")
        .replace("lɣ", "lɡ")
        .replace("nɣ", "nɡ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("lð̞", "ld")
        .replace("áð̞a", "áʔa")
        .replace("áð̞o", "áʔo")
        .replace("óð̞a", "óʔa")
        .replace("óð̞o", "óʔo")
        .replace('z', "s")
        .replace('s', "ɬ")
        .replace("ɬ#", "ɬ̬#")
        .replace("eɬ̬#", "el͡ʒ#")
        .replace("éɬ̬#", "él͡ʒ#")
        .replace("ɬɣ", "ɬ̬ɣ")
        .replace("ɬk", "ɬ̬k")
        .replace("ɬð̞", "ɬ̬ð̞")
        .replace("ɬm", "ɬ̬m")
        .replace("ɬv", "ɬ̬v")
        .replace("aɬá", "aɬ̬á")
        .replace("aɬó", "aɬ̬ó")
        .replace("aɬé", "aɬ̬é")
        .replace("aɬí", "aɬ̬í")
        .replace("aɬú", "aɬ̬ú")
        .replace("áɬa", "áɬ̬a")
        .replace("áɬo", "áɬ̬o")
        .replace("áɬe", "áɬ̬e")
        .replace("áɬi", "áɬ̬i")
        .replace("áɬu", "áɬ̬u")
        .replace("oɬá", "oɬ̬á")
        .replace("oɬó", "oɬ̬ó")
        .replace("oɬé", "oɬ̬é")
        .replace("oɬí", "oɬ̬í")
        .replace("oɬú", "oɬ̬ú")
        .replace("óɬa", "óɬ̬a")
        .replace("óɬo", "óɬ̬o")
        .replace("óɬe", "óɬ̬e")
        .replace("óɬi", "óɬ̬i")
        .replace("óɬu", "óɬ̬u")
        .replace("eɬá", "eɬ̬á")
        .replace("eɬó", "eɬ̬ó")
        .replace("eɬé", "eɬ̬é")
        .replace("eɬí", "eɬ̬í")
        .replace("eɬú", "eɬ̬ú")
        .replace("éɬa", "éɬ̬a")
        .replace("éɬo", "éɬ̬o")
        .replace("éɬe", "éɬ̬e")
        .replace("éɬi", "éɬ̬i")
        .replace("éɬu", "éɬ̬u")
        .replace("iɬá", "iɬ̬á")
        .replace("iɬó", "iɬ̬ó")
        .replace("iɬé", "iɬ̬é")
        .replace("iɬí", "iɬ̬í")
        .replace("iɬú", "iɬ̬ú")
        .replace("íɬa", "íɬ̬a")
        .replace("íɬo", "íɬ̬o")
        .replace("íɬe", "íɬ̬e")
        .replace("íɬi", "íɬ̬i")
        .replace("íɬu", "íɬ̬u")
        .replace("uɬá", "uɬ̬á")
        .replace("uɬó", "uɬ̬ó")
        .replace("uɬé", "uɬ̬é")
        .replace("uɬí", "uɬ̬í")
        .replace("uɬú", "uɬ̬ú")
        .replace("úɬa", "úɬ̬a")
        .replace("úɬo", "úɬ̬o")
        .replace("úɬe", "úɬ̬e")
        .replace("úɬi", "úɬ̬i")
        .replace("úɬu", "úɬ̬u")
        .replace("kɬɬe", "kɬe")
        .replace("kɬɬi", "kɬi")
        .replace('ɬ', "ɬ̻")
        .replace("ɬ̻̬", "ɬ̬")
        .replace("mn", "nn")
        .replace("nt͡ʃ", "nʲt͡ʃ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɡ", "ŋɡ")
        .replace("nm", "ɱ̥m")
        .replace("n# #m", "m# #m")
        .replace("n# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("n# #β", "m# #β")
        .replace("n# #b", "m# #b")
        .replace("np", "mp")
        .replace("n# #p", "m# #p")
        .replace("nf", "ɱf")
        .replace("n# #f", "ɱ# #f")
        .replace('ñ', "ɲ")
        .replace("ia", "ja")
        .replace("ie", "je")
        .replace("io", "jo")
        .replace("iu", "ju")
        .replace("iá", "já")
        .replace("ié", "jé")
        .replace("ió", "jó")
        .replace("iú", "jú")
        .replace("ea", "ia")
        .replace("eá", "iá")
        .replace("ká", "kɑ")
        .replace("ka", "kɑ")
        .replace('á', "ɐ̞")
        .replace('a', "ɐ")
        .replace('ó', "ɔ̝")
        .replace("o#", "ʊ#")
        .replace("oɬ̬#", "ʊɬ̬#")
        .replace('o', "o̞")
        .replace("lʊ#", "lo̞#")
        .replace("lʊɬ̬#", "lo̞ɬ̬#")
        .replace("ɾʊ#", "ɾo̞#")
        .replace("ɾʊɬ̬#", "ɾo̞ɬ̬#")
        .replace("mʊ#", "mo̞#")
        .replace("mʊɬ̬#", "mo̞ɬ̬#")
        .replace("nʊ#", "no̞#")
        .replace("nʊɬ̬#", "no̞ɬ̬#")
        .replace("ɲʊ#", "ɲo̞#")
        .replace("ɲʊɬ̬#", "ɲo̞ɬ̬#")
        .replace('é', "ɛ̝")
        .replace('e', "e̞")
        .replace('í', "i")
        .replace('i', "i̞")
        .replace('ú', "u")
        .replace('u', "u̞")
        .replace("mu̞", "mũ̞")
        .replace("ɔɱ̥m", "ɔ̃ɱ̥m")
        .replace("e̞ɱ̥m", "ẽ̞ɱ̥m")
        .replace("i̞ɱ̥m", "ĩ̞ɱ̥m")
        .replace("u̞ɱ̥m", "ũ̞ɱ̥m")
        .replace("ɐnn", "ɐ̃nn")
        .replace("o̞nn", "õ̞nn")
        .replace("e̞nn", "ẽ̞nn")
        .replace("i̞nn", "ĩ̞nn")
        .replace("u̞nn", "ũ̞nn")
        .replace("ɐ̞ɱ", "ɐ̞̃ɱ")
        .replace("o̞ɱ", "õ̞ɱ")
        .replace("e̞ɱ", "ẽɱ")
        .replace("ɐɱ", "ɐ̃ɱ")
        .replace("ɑɱ", "ɑ̃ɱ")
        .replace("ɔ̝ɱ", "ɔ̝̃ɱ")
        .replace("ɔɱ", "ɔ̃ɱ")
        .replace("ɛ̝ɱ", "ɛ̝̃ɱ")
        .replace("i̞ɱ", "ĩ̞ɱ")
        .replace("u̞ɱ", "ũ̞ɱ")
        .replace("ɐ̞ŋ", "ɐ̞̃ŋ")
        .replace("o̞ŋ", "õ̞ŋ")
        .replace("e̞ŋ", "ẽ̞ŋ")
        .replace("ɐŋ", "ɐ̃ŋ")
        .replace("ɑŋ", "ɑ̃ŋ")
        .replace("ɔ̝ŋ", "ɔ̝̃ŋ")
        .replace("ɔŋ", "ɔ̃ŋ")
        .replace("ɛ̝ŋ", "ɛ̝̃ŋ")
        .replace("i̞ŋ", "ĩ̞ŋ")
        .replace("u̞ŋ", "ũ̞ŋ")
        .replace("ɐ̞n̪", "ɐ̞̃n̪")
        .replace("ɑn̪", "ɑ̃n̪")
        .replace("o̞n̪", "õ̞n̪")
        .replace("e̞n̪", "ẽ̞n̪")
        .replace("ɐn̪", "ɐ̃n̪")
        .replace("ɔ̝n̪", "ɔ̝̃n̪")
        .replace("ɔn̪", "ɔ̃n̪")
        .replace("ɛ̝n̪", "ɛ̝̃n̪")
        .replace("i̞n̪", "ĩ̞n̪")
        .replace("u̞n̪", "ũ̞n̪")
        .replace("ɐnʲ", "ɐ̃nʲ")
        .replace("ɐ̞nʲ", "ɐ̞̃nʲ")
        .replace("ɑnʲ", "ɑ̃nʲ")
        .replace("o̞nʲ", "õ̞nʲ")
        .replace("ɔ̝nʲ", "ɔ̝̃nʲ")
        .replace("ɔnʲ", "ɔ̃nʲ")
        .replace("e̞nʲ", "ẽ̞nʲ")
        .replace("ɛ̝nʲ", "ɛ̝̃nʲ")
        .replace("i̞nʲ", "ĩ̞nʲ")
        .replace("u̞nʲ", "ũ̞nʲ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("BOGOTÁ, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("BOGOTÁ, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Bogotá" + reset + ", " + cyan + "CO" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// LETICIA: IPA

pub fn spacoleticia(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);
    let spaacc_i = spaaccent_i(&spaacc_o);
    let spaacc_u = spaaccent_u(&spaacc_i);

    let strmod = &spaacc_u
        .replace("ch", "t͡ʃ")
        .replace("ce", "se")
        .replace("cé", "sé")
        .replace("ci", "si")
        .replace("cí", "sí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace("ké", "kɛ̝")
        .replace("ke", "kɛ̝")
        .replace("kó", "kɔ̝")
        .replace("ko", "kɔ̝")
        .replace('x', "ks")
        .replace('h', "")
        .replace('j', "x")
        .replace("ge", "xe")
        .replace("gé", "xé")
        .replace("gi", "xi")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("y#", "i#")
        .replace('y', "ɟ͡ʝ")
        .replace("ll", "ɟ͡ʝ")
        .replace("lt͡ʃ", "lʲt͡ʃ")
        .replace("lt", "l̪t")
        .replace('b', "β")
        .replace("#β", "#b")
        .replace("mβ", "mb")
        .replace("lβ", "lb")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ")
        .replace("lɣ", "lɡ")
        .replace("nɣ", "nɡ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("lð̞", "ld")
        .replace("áð̞a", "áʔa")
        .replace("áð̞o", "áʔo")
        .replace("óð̞a", "óʔa")
        .replace("óð̞o", "óʔo")
        .replace('z', "s")
        .replace('s', "ɬ")
        .replace("ɬ#", "ɬ̬#")
        .replace("eɬ̬#", "el͡ʒ#")
        .replace("éɬ̬#", "él͡ʒ#")
        .replace("ɬɣ", "ɬ̬ɣ")
        .replace("ɬk", "ɬ̬k")
        .replace("ɬð̞", "ɬ̬ð̞")
        .replace("ɬm", "ɬ̬m")
        .replace("ɬv", "ɬ̬v")
        .replace("aɬá", "aɬ̬á")
        .replace("aɬó", "aɬ̬ó")
        .replace("aɬé", "aɬ̬é")
        .replace("aɬí", "aɬ̬í")
        .replace("aɬú", "aɬ̬ú")
        .replace("áɬa", "áɬ̬a")
        .replace("áɬo", "áɬ̬o")
        .replace("áɬe", "áɬ̬e")
        .replace("áɬi", "áɬ̬i")
        .replace("áɬu", "áɬ̬u")
        .replace("oɬá", "oɬ̬á")
        .replace("oɬó", "oɬ̬ó")
        .replace("oɬé", "oɬ̬é")
        .replace("oɬí", "oɬ̬í")
        .replace("oɬú", "oɬ̬ú")
        .replace("óɬa", "óɬ̬a")
        .replace("óɬo", "óɬ̬o")
        .replace("óɬe", "óɬ̬e")
        .replace("óɬi", "óɬ̬i")
        .replace("óɬu", "óɬ̬u")
        .replace("eɬá", "eɬ̬á")
        .replace("eɬó", "eɬ̬ó")
        .replace("eɬé", "eɬ̬é")
        .replace("eɬí", "eɬ̬í")
        .replace("eɬú", "eɬ̬ú")
        .replace("éɬa", "éɬ̬a")
        .replace("éɬo", "éɬ̬o")
        .replace("éɬe", "éɬ̬e")
        .replace("éɬi", "éɬ̬i")
        .replace("éɬu", "éɬ̬u")
        .replace("iɬá", "iɬ̬á")
        .replace("iɬó", "iɬ̬ó")
        .replace("iɬé", "iɬ̬é")
        .replace("iɬí", "iɬ̬í")
        .replace("iɬú", "iɬ̬ú")
        .replace("íɬa", "íɬ̬a")
        .replace("íɬo", "íɬ̬o")
        .replace("íɬe", "íɬ̬e")
        .replace("íɬi", "íɬ̬i")
        .replace("íɬu", "íɬ̬u")
        .replace("uɬá", "uɬ̬á")
        .replace("uɬó", "uɬ̬ó")
        .replace("uɬé", "uɬ̬é")
        .replace("uɬí", "uɬ̬í")
        .replace("uɬú", "uɬ̬ú")
        .replace("úɬa", "úɬ̬a")
        .replace("úɬo", "úɬ̬o")
        .replace("úɬe", "úɬ̬e")
        .replace("úɬi", "úɬ̬i")
        .replace("úɬu", "úɬ̬u")
        .replace("kɬɬe", "kɬe")
        .replace("kɬɬi", "kɬi")
        .replace('ɬ', "ɬ̻")
        .replace("ɬ̻̬", "ɬ̬")
        .replace("mn", "nn")
        .replace("nt͡ʃ", "nʲt͡ʃ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɡ", "ŋɡ")
        .replace("nx", "ŋx")
        .replace("n#", "ŋ#")
        .replace("nm", "ɱ̥m")
        .replace("ŋ# #m", "ɱ# #m")
        .replace("ŋ# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("ŋ# #β", "ɱ# #β")
        .replace("ŋ# #b", "ɱ# #b")
        .replace("np", "mp")
        .replace("ŋ# #p", "ɱ# #p")
        .replace('f', "ɸ")
        .replace("nɸ", "mɸ")
        .replace("ŋ# #ɸ", "ɱ# #f̟")
        .replace('ñ', "ɲ")
        .replace("ia", "ja")
        .replace("ie", "je")
        .replace("io", "jo")
        .replace("iu", "ju")
        .replace("iá", "já")
        .replace("ié", "jé")
        .replace("ió", "jó")
        .replace("iú", "jú")
        .replace("ea", "ia")
        .replace("eá", "iá")
        .replace('á', "æ̞̈")
        .replace('a', "æ̈")
        .replace('ó', "ə̠")
        .replace("o#", "ʊ̈#")
        .replace("oɬ̬#", "ʊ̈ɬ̬#")
        .replace('o', "o̽")
        .replace("lʊ̈#", "lo̞#")
        .replace("lʊ̈ɬ̬#", "lo̞ɬ̬#")
        .replace("ɾʊ̈#", "ɾo̞#")
        .replace("ɾʊ̈ɬ̬#", "ɾo̞ɬ̬#")
        .replace("mʊ̈#", "mö#")
        .replace("mʊ̈ɬ̬#", "möɬ̬#")
        .replace("nʊ̈#", "nö#")
        .replace("nʊ̈ɬ̬#", "nöɬ̬#")
        .replace("ɲʊ̈#", "ɲö#")
        .replace("ɲʊ̈ɬ̬#", "ɲöɬ̬#")
        .replace('é', "ə̟")
        .replace('e', "e̽")
        .replace('í', "i")
        .replace('i', "ɪ")
        .replace('ú', "u")
        .replace('u', "ʊ")
        .replace("mʊ", "mʊ̃")
        .replace("ɔ̝ɱ̥m", "ɔ̝̃ɱ̥m")
        .replace("e̽ɱ̥m", "ẽ̞ɱ̥m")
        .replace("ɪɱ̥m", "ɪ̃ɱ̥m")
        .replace("ʊɱ̥m", "ʊ̃ɱ̥m")
        .replace("æ̈nn", "æ̠̃nn")
        .replace("o̽nn", "õ̞nn")
        .replace("e̽nn", "ẽ̞nn")
        .replace("ɪnn", "ɪ̃nn")
        .replace("ʊnn", "ʊ̃nn")
        .replace("æ̞̈ɱ", "æ̞̃ɱ")
        .replace("o̽ɱ", "õ̞ɱ")
        .replace("e̽ɱ", "ẽɱ")
        .replace("æ̈ɱ", "æ̠̃ɱ")
        .replace("ə̠ɱ", "ə̠̃ɱ")
        .replace("ɔ̝ɱ", "ɔ̝̃ɱ")
        .replace("ə̟ɱ", "ə̟̃ɱ")
        .replace("ɪɱ", "ɪ̃ɱ")
        .replace("ʊɱ", "ʊ̃ɱ")
        .replace("æ̞̈ŋ", "æ̞̃ŋ")
        .replace("o̽ŋ", "õ̞ŋ")
        .replace("e̽ŋ", "ẽ̞ŋ")
        .replace("æ̈ŋ", "æ̠̃ŋ")
        .replace("ə̠ŋ", "ə̠̃ŋ")
        .replace("ɔ̝ŋ", "ɔ̝̃ŋ")
        .replace("ə̟ŋ", "ə̟̃ŋ")
        .replace("ɪŋ", "ɪ̃ŋ")
        .replace("ʊŋ", "ʊ̃ŋ")
        .replace("æ̞̈n̪", "æ̞̃n̪")
        .replace("o̽n̪", "õ̞n̪")
        .replace("e̽n̪", "ẽ̞n̪")
        .replace("æ̈n̪", "æ̠̃n̪")
        .replace("ə̠n̪", "ə̠̃n̪")
        .replace("ɔ̝n̪", "ɔ̝̃n̪")
        .replace("ə̟n̪", "ə̟̃n̪")
        .replace("ɪn̪", "ɪ̃n̪")
        .replace("ʊn̪", "ʊ̃n̪")
        .replace("æ̈nʲ", "æ̠̃nʲ")
        .replace("æ̞̈nʲ", "æ̞̃nʲ")
        .replace("o̽nʲ", "õ̞nʲ")
        .replace("ə̠nʲ", "ə̠̃nʲ")
        .replace("ɔ̝nʲ", "ɔ̝̃nʲ")
        .replace("e̽nʲ", "ẽ̞nʲ")
        .replace("ə̟nʲ", "ə̟̃nʲ")
        .replace("ɪnʲ", "ɪ̃nʲ")
        .replace("ʊnʲ", "ʊ̃nʲ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("LETICIA, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("LETICIA, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Leticia" + reset + ", " + cyan + "CO" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// MEDELLÍN: IPA

pub fn spacomedellin(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);
    let spaacc_i = spaaccent_i(&spaacc_o);
    let spaacc_u = spaaccent_u(&spaacc_i);

    let strmod = &spaacc_u
        .replace("ch", "ʈ͡ʂʲ")
        .replace("ce", "se")
        .replace("cé", "sé")
        .replace("ci", "ʒi")
        .replace("cí", "ʒí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace("ké", "kʰe̞ˑ")
        .replace("ke", "kʰe̞")
        .replace("kó", "kʰɔ̝ˑ")
        .replace("ko", "kʰɔ̝")
        .replace('x', "ks")
        .replace('h', "")
        .replace('j', "h")
        .replace("ge", "he")
        .replace("gé", "hé")
        .replace("gi", "hi")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("y#", "i#")
        .replace('y', "ɟ͡ʝ")
        .replace("lle", "d͡ʑe")
        .replace("ll", "ɟ͡ʝ")
        .replace("lʈ͡ʂʲ", "lʲʈ͡ʂʲ")
        .replace("lt", "l̪t")
        .replace('b', "β")
        .replace("#β", "#b")
        .replace("mβ", "ɱb̪")
        .replace("lβ", "lb̪")
        .replace("l# #b", "l# #b̪")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ")
        .replace("lɣ", "lɡ")
        .replace("nɣ", "nɡ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("lð̞", "ld")
        .replace("áð̞a", "áʔa")
        .replace("áð̞o", "áʔo")
        .replace("óð̞a", "óʔa")
        .replace("óð̞o", "óʔo")
        .replace('z', "s")
        .replace('s', "s̺")
        .replace("s̺#", "s̬#")
        .replace("es̬#", "ez̺#")
        .replace("és̬#", "éz̺#")
        .replace("s̺ɣ", "s̬ɣ")
        .replace("s̺k", "s̬k")
        .replace("s̺ð̞", "s̬ð̞")
        .replace("s̺m", "s̬m")
        .replace("s̺v", "s̬v")
        .replace("as̺a", "az̺a")
        .replace("as̺o", "az̺o")
        .replace("as̺e", "az̺e")
        .replace("as̺i", "az̺i")
        .replace("as̺u", "az̺u")
        .replace("as̺á", "az̺á")
        .replace("as̺ó", "az̺ó")
        .replace("as̺é", "az̺é")
        .replace("as̺í", "az̺í")
        .replace("as̺ú", "az̺ú")
        .replace("ás̺a", "áz̺a")
        .replace("ás̺o", "áz̺o")
        .replace("ás̺e", "áz̺e")
        .replace("ás̺i", "áz̺i")
        .replace("ás̺u", "áz̺u")
        .replace("os̺a", "oz̺a")
        .replace("os̺o", "oz̺o")
        .replace("os̺e", "oz̺e")
        .replace("os̺i", "oz̺i")
        .replace("os̺u", "oz̺u")
        .replace("os̺á", "oz̺á")
        .replace("os̺ó", "oz̺ó")
        .replace("os̺é", "oz̺é")
        .replace("os̺í", "oz̺í")
        .replace("os̺ú", "oz̺ú")
        .replace("ós̺a", "óz̺a")
        .replace("ós̺o", "óz̺o")
        .replace("ós̺e", "óz̺e")
        .replace("ós̺i", "óz̺i")
        .replace("ós̺u", "óz̺u")
        .replace("es̺a", "ez̺a")
        .replace("es̺o", "ez̺o")
        .replace("es̺e", "ez̺e")
        .replace("es̺i", "ez̺i")
        .replace("es̺u", "ez̺u")
        .replace("es̺á", "ez̺á")
        .replace("es̺ó", "ez̺ó")
        .replace("es̺é", "ez̺é")
        .replace("es̺í", "ez̺í")
        .replace("es̺ú", "ez̺ú")
        .replace("és̺a", "éz̺a")
        .replace("és̺o", "éz̺o")
        .replace("és̺e", "éz̺e")
        .replace("és̺i", "éz̺i")
        .replace("és̺u", "éz̺u")
        .replace("is̺a", "iz̺a")
        .replace("is̺o", "iz̺o")
        .replace("is̺e", "iz̺e")
        .replace("is̺i", "iz̺i")
        .replace("is̺u", "iz̺u")
        .replace("is̺á", "iz̺á")
        .replace("is̺ó", "iz̺ó")
        .replace("is̺é", "iz̺é")
        .replace("is̺í", "iz̺í")
        .replace("is̺ú", "iz̺ú")
        .replace("ís̺a", "íz̺a")
        .replace("ís̺o", "íz̺o")
        .replace("ís̺e", "íz̺e")
        .replace("ís̺i", "íz̺i")
        .replace("ís̺u", "íz̺u")
        .replace("us̺a", "uz̺a")
        .replace("us̺o", "uz̺o")
        .replace("us̺e", "uz̺e")
        .replace("us̺i", "uz̺i")
        .replace("us̺u", "uz̺u")
        .replace("us̺á", "uz̺á")
        .replace("us̺ó", "uz̺ó")
        .replace("us̺é", "uz̺é")
        .replace("us̺í", "uz̺í")
        .replace("us̺ú", "uz̺ú")
        .replace("ús̺a", "úz̺a")
        .replace("ús̺o", "úz̺o")
        .replace("ús̺e", "úz̺e")
        .replace("ús̺i", "úz̺i")
        .replace("ús̺u", "úz̺u")
        .replace("ks̺s̺e", "ks̺e")
        .replace("ks̺s̺i", "ks̺i")
        .replace("mn", "nn")
        .replace("nʈ͡ʂʲ", "nʲʈ͡ʂʲ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɡ", "ŋɡ")
        .replace("n#", "ŋ#")
        .replace("nm", "ɱ̥m")
        .replace("ŋ# #m", "ɱ# #m")
        .replace("ŋ# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("ŋ# #β", "ɱ# #β")
        .replace("ŋ# #b", "ɱ# #b")
        .replace("np", "mp")
        .replace("ŋ# #p", "ɱ# #p")
        .replace('f', "ɸ")
        .replace("nɸ", "mɸ")
        .replace("ŋ# #ɸ", "ɱ# #f̟")
        .replace('ñ', "ɲ")
        .replace("ia", "ja")
        .replace("ie", "je")
        .replace("io", "jo")
        .replace("iu", "ju")
        .replace("iá", "já")
        .replace("ié", "jé")
        .replace("ió", "jó")
        .replace("iú", "jú")
        .replace("ea", "ia")
        .replace("eá", "iá")
        .replace("ká", "kɑˑ")
        .replace("ka", "kɑ")
        .replace('á', "ɐ̞ˑ")
        .replace('a', "ɐ")
        .replace("ʝɐ̞", "ɟ͡ʝɐ̞")
        .replace('ó', "o̞ˑ")
        .replace("o#", "ʊ#")
        .replace("os̬#", "ʊs̬#")
        .replace("lʊ#", "lo#")
        .replace("lʊs̬#", "los̬#")
        .replace("ɾʊ#", "ɾo#")
        .replace("ɾʊs̬#", "ɾos̬#")
        .replace("ɡʊ#", "ɡə̠#")
        .replace("ɡʊs̬#", "ɡə̠s̬#")
        .replace("ɣʊ#", "ɣə̠#")
        .replace("ɣʊs̬#", "ɣə̠s̬#")
        .replace("mʊ#", "mo̞#")
        .replace("mʊs̬#", "mo̞s̬#")
        .replace("nʊ#", "no̞#")
        .replace("nʊs̬#", "no̞s̬#")
        .replace("ɲʊ#", "ɲo̞#")
        .replace("ɲʊs̬#", "ɲo̞s̬#")
        .replace('é', "e̞ˑ")
        .replace('í', "iˑ")
        .replace('i', "i̞")
        .replace('ú', "uˑ")
        .replace('u', "u̞")
        .replace("ɟ͡ʝʊ", "ɟ͡ʝö")
        .replace("ɔ̝ɱ̥m", "ɔ̝̃ɱ̥m")
        .replace("eɱ̥m", "ẽɱ̥m")
        .replace("i̞ɱ̥m", "ĩ̞ɱ̥m")
        .replace("u̞ɱ̥m", "ũ̞ɱ̥m")
        .replace("ɐnn", "ɐ̃nn")
        .replace("onn", "õnn")
        .replace("enn", "ẽnn")
        .replace("i̞nn", "ĩ̞nn")
        .replace("i̞ˑnn", "ĩ̞ˑnn")
        .replace("u̞nn", "ũ̞nn")
        .replace("u̞ˑnn", "ũ̞ˑnn")
        .replace("ɐ̞ˑɱ", "ɐ̞̃ˑɱ")
        .replace("ɐ̞ɱ", "ɐ̞̃ɱ")
        .replace("oɱ", "õɱ")
        .replace("eɱ", "ẽɱ")
        .replace("ɐɱ", "ɐ̃ɱ")
        .replace("ɑɱ", "ɑ̃ɱ")
        .replace("ɑˑɱ", "ɑ̃ˑɱ")
        .replace("o̞ɱ", "õ̞ɱ")
        .replace("o̞ˑɱ", "õ̞ˑɱ")
        .replace("ɔ̝ɱ", "ɔ̝̃ɱ")
        .replace("ɔ̝ˑɱ", "ɔ̝̃ˑɱ")
        .replace("e̞ɱ", "ẽ̞ɱ")
        .replace("e̞ˑɱ", "ẽ̞ˑɱ")
        .replace("i̞ɱ", "ĩ̞ɱ")
        .replace("i̞ˑɱ", "ĩ̞ˑɱ")
        .replace("u̞ɱ", "ũ̞ɱ")
        .replace("u̞ˑɱ", "ũ̞ˑɱ")
        .replace("ɐ̞ˑŋ", "ɐ̞̃ˑŋ")
        .replace("oŋ", "õŋ")
        .replace("eŋ", "ẽŋ")
        .replace("ɐŋ", "ɐ̃ŋ")
        .replace("ɑŋ", "ɑ̃ŋ")
        .replace("ɑˑŋ", "ɑ̃ˑŋ")
        .replace("o̞ˑŋ", "õ̞ˑŋ")
        .replace("ɔ̝ŋ", "ɔ̝̃ŋ")
        .replace("ɔ̝ˑŋ", "ɔ̝̃ˑŋ")
        .replace("e̞ˑŋ", "ẽ̞ˑŋ")
        .replace("i̞ŋ", "ĩ̞ŋ")
        .replace("i̞ˑŋ", "ĩ̞ˑŋ")
        .replace("u̞ŋ", "ũ̞ŋ")
        .replace("u̞ˑŋ", "ũ̞ˑŋ")
        .replace("ɐ̞ˑn̪", "ɐ̞̃ˑn̪")
        .replace("ɑn̪", "ɑ̃n̪")
        .replace("ɑˑn̪", "ɑ̃ˑn̪")
        .replace("on̪", "õn̪")
        .replace("en̪", "ẽn̪")
        .replace("ɐn̪", "ɐ̃n̪")
        .replace("o̞ˑn̪", "õ̞ˑn̪")
        .replace("ɔ̝n̪", "ɔ̝̃n̪")
        .replace("ɔ̝ˑn̪", "ɔ̝̃ˑn̪")
        .replace("e̞ˑn̪", "ẽ̞ˑn̪")
        .replace("i̞n̪", "ĩ̞n̪")
        .replace("i̞ˑn̪", "ĩ̞ˑn̪")
        .replace("u̞n̪", "ũ̞n̪")
        .replace("u̞ˑn̪", "ũ̞ˑn̪")
        .replace("ɐnʲ", "ɐ̃nʲ")
        .replace("ɐ̞ˑnʲ", "ɐ̞̃ˑnʲ")
        .replace("ɑnʲ", "ɑ̃nʲ")
        .replace("ɑˑnʲ", "ɑ̃ˑnʲ")
        .replace("onʲ", "õnʲ")
        .replace("o̞ˑnʲ", "õ̞ˑnʲ")
        .replace("ɔ̝nʲ", "ɔ̝̃nʲ")
        .replace("ɔ̝ˑnʲ", "ɔ̝̃ˑnʲ")
        .replace("enʲ", "ẽnʲ")
        .replace("e̞ˑnʲ", "ẽ̞ˑnʲ")
        .replace("i̞nʲ", "ĩ̞nʲ")
        .replace("i̞ˑnʲ", "ĩ̞ˑnʲ")
        .replace("u̞nʲ", "ũ̞nʲ")
        .replace("u̞ˑnʲ", "ũ̞ˑnʲ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("MEDELLÍN, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("MEDELLÍN, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Medellín" + reset + ", " + cyan + "CO" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// PASTO: IPA

pub fn spacopasto(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);
    let spaacc_i = spaaccent_i(&spaacc_o);
    let spaacc_u = spaaccent_u(&spaacc_i);

    let strmod = &spaacc_u
        .replace("ch", "t͡ʃ")
        .replace("ce", "se")
        .replace("cé", "sé")
        .replace("ci", "si")
        .replace("cí", "sí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace("ké", "kɛ̈ː")
        .replace("ke", "kɛ̈")
        .replace("kó", "kɔ̈ː")
        .replace("ko", "kɔ̈")
        .replace('x', "ks")
        .replace('h', "")
        .replace('j', "x")
        .replace("ge", "xe")
        .replace("gé", "xé")
        .replace("gi", "xi")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("y#", "i#")
        .replace('y', "ʝ")
        .replace("ll", "ʎ")
        .replace("lt͡ʃ", "lʲt͡ʃ")
        .replace("lt", "l̪t")
        .replace('b', "β")
        .replace("mβ", "mb")
        .replace("lβ", "lb")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ")
        .replace("lɣ", "lɡ")
        .replace("nɣ", "nɡ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("lð̞", "ld")
        .replace('z', "s")
        .replace('s', "ɬ")
        .replace("ɬ#", "ɬ̬#")
        .replace("eɬ̬#", "el͡ʒ#")
        .replace("éɬ̬#", "él͡ʒ#")
        .replace("ɬɣ", "ɬ̬ɣ")
        .replace("ɬk", "ɬ̬k")
        .replace("ɬð̞", "ɬ̬ð̞")
        .replace("ɬm", "ɬ̬m")
        .replace("ɬv", "ɬ̬v")
        .replace("aɬá", "aɬ̬á")
        .replace("aɬó", "aɬ̬ó")
        .replace("aɬé", "aɬ̬é")
        .replace("aɬí", "aɬ̬í")
        .replace("aɬú", "aɬ̬ú")
        .replace("áɬa", "áɬ̬a")
        .replace("áɬo", "áɬ̬o")
        .replace("áɬe", "áɬ̬e")
        .replace("áɬi", "áɬ̬i")
        .replace("áɬu", "áɬ̬u")
        .replace("oɬá", "oɬ̬á")
        .replace("oɬó", "oɬ̬ó")
        .replace("oɬé", "oɬ̬é")
        .replace("oɬí", "oɬ̬í")
        .replace("oɬú", "oɬ̬ú")
        .replace("óɬa", "óɬ̬a")
        .replace("óɬo", "óɬ̬o")
        .replace("óɬe", "óɬ̬e")
        .replace("óɬi", "óɬ̬i")
        .replace("óɬu", "óɬ̬u")
        .replace("eɬá", "eɬ̬á")
        .replace("eɬó", "eɬ̬ó")
        .replace("eɬé", "eɬ̬é")
        .replace("eɬí", "eɬ̬í")
        .replace("eɬú", "eɬ̬ú")
        .replace("éɬa", "éɬ̬a")
        .replace("éɬo", "éɬ̬o")
        .replace("éɬe", "éɬ̬e")
        .replace("éɬi", "éɬ̬i")
        .replace("éɬu", "éɬ̬u")
        .replace("iɬá", "iɬ̬á")
        .replace("iɬó", "iɬ̬ó")
        .replace("iɬé", "iɬ̬é")
        .replace("iɬí", "iɬ̬í")
        .replace("iɬú", "iɬ̬ú")
        .replace("íɬa", "íɬ̬a")
        .replace("íɬo", "íɬ̬o")
        .replace("íɬe", "íɬ̬e")
        .replace("íɬi", "íɬ̬i")
        .replace("íɬu", "íɬ̬u")
        .replace("uɬá", "uɬ̬á")
        .replace("uɬó", "uɬ̬ó")
        .replace("uɬé", "uɬ̬é")
        .replace("uɬí", "uɬ̬í")
        .replace("uɬú", "uɬ̬ú")
        .replace("úɬa", "úɬ̬a")
        .replace("úɬo", "úɬ̬o")
        .replace("úɬe", "úɬ̬e")
        .replace("úɬi", "úɬ̬i")
        .replace("úɬu", "úɬ̬u")
        .replace("kɬɬe", "kɬe")
        .replace("kɬɬi", "kɬi")
        .replace('ɬ', "ɬ̻")
        .replace("ɬ̻̬", "ɬ̬")
        .replace("mn", "nn")
        .replace("nt͡ʃ", "nʲt͡ʃ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɡ", "ŋɡ")
        .replace("nx", "ŋx")
        .replace("nm", "ɱ̥m")
        .replace("n# #m", "m# #m")
        .replace("n# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("n# #β", "m# #β")
        .replace("np", "mp")
        .replace("n# #p", "m# #p")
        .replace("nf", "ɱf")
        .replace("n# #f", "ɱ# #f")
        .replace('ñ', "ɲ")
        .replace('f', "f̟")
        .replace("ia", "ja")
        .replace("ie", "je")
        .replace("io", "jo")
        .replace("iu", "ju")
        .replace("iá", "já")
        .replace("ié", "jé")
        .replace("ió", "jó")
        .replace("iú", "jú")
        .replace("ea", "ia")
        .replace("eá", "iá")
        .replace('á', "æ̞̈ː")
        .replace('a', "æ̈")
        .replace('ó', "ɔ̈ː")
        .replace('o', "ɞ")
        .replace("lɞ#", "lɔ#")
        .replace("lɞɬ̬#", "lɔɬ̬#")
        .replace("ɾɞ#", "ɾɔ#")
        .replace("ɾɞɬ̬#", "ɾɔɬ̬#")
        .replace("mɞ#", "mɔ̽#")
        .replace("mɞɬ̬#", "mɔ̽ɬ̬#")
        .replace("nɞ#", "nɔ̽#")
        .replace("nɞɬ̬#", "nɔ̽ɬ̬#")
        .replace("ɲɞ#", "ɲɔ̽#")
        .replace("ɲɞɬ̬#", "ɲɔ̽ɬ̬#")
        .replace('é', "ɛ̈ː")
        .replace('e', "ɜ")
        .replace('í', "iː")
        .replace('i', "e")
        .replace('ú', "uː")
        .replace('u', "o")
        .replace("mo", "mõ")
        .replace("ɔ̈ɱ̥m", "ɔ̟̃ɱ̥m")
        .replace("ɜɱ̥m", "ɜ̃ɱ̥m")
        .replace("eɱ̥m", "ẽɱ̥m")
        .replace("oɱ̥m", "õɱ̥m")
        .replace("æ̈nn", "æ̠̃nn")
        .replace("ɞnn", "ɞ̃nn")
        .replace("ɜnn", "ɜ̃nn")
        .replace("enn", "ẽnn")
        .replace("eːnn", "ẽːnn")
        .replace("onn", "õnn")
        .replace("oːnn", "õːnn")
        .replace("æ̞̈ːɱ", "æ̞̃ːɱ")
        .replace("ɞɱ", "ɞ̃ɱ")
        .replace("ɜɱ", "ɜ̃ɱ")
        .replace("æ̈ɱ", "æ̠̃ɱ")
        .replace("ɔ̈ɱ", "ɔ̟̃ɱ")
        .replace("ɔ̈ːɱ", "ɔ̟̃ːɱ")
        .replace("ɛ̈ɱ", "ɛ̠̃ɱ")
        .replace("ɛ̈ːɱ", "ɛ̠̃ːɱ")
        .replace("eɱ", "ẽɱ")
        .replace("eːɱ", "ẽːɱ")
        .replace("oɱ", "õɱ")
        .replace("oːɱ", "õːɱ")
        .replace("æ̞̈ːŋ", "æ̞̃ːŋ")
        .replace("ɞŋ", "ɞ̃ŋ")
        .replace("ɜŋ", "ɜ̃ŋ")
        .replace("æ̈ŋ", "æ̠̃ŋ")
        .replace("ɔ̈ŋ", "ɔ̟̃ŋ")
        .replace("ɔ̈ːŋ", "ɔ̟̃ːŋ")
        .replace("ɛ̈ŋ", "ɛ̠̃ŋ")
        .replace("ɛ̈ːŋ", "ɛ̠̃ːŋ")
        .replace("eŋ", "ẽŋ")
        .replace("eːŋ", "ẽːŋ")
        .replace("oŋ", "õŋ")
        .replace("oːŋ", "õːŋ")
        .replace("æ̞̈ːn̪", "æ̞̃ːn̪")
        .replace("ɞn̪", "ɞ̃n̪")
        .replace("ɜn̪", "ɜ̃n̪")
        .replace("æ̈n̪", "æ̠̃n̪")
        .replace("ɔ̈n̪", "ɔ̟̃n̪")
        .replace("ɔ̈ːn̪", "ɔ̟̃ːn̪")
        .replace("ɛ̈n̪", "ɛ̠̃n̪")
        .replace("ɛ̈ːn̪", "ɛ̠̃ːn̪")
        .replace("en̪", "ẽn̪")
        .replace("eːn̪", "ẽːn̪")
        .replace("on̪", "õn̪")
        .replace("oːn̪", "õːn̪")
        .replace("æ̈nʲ", "æ̠̃nʲ")
        .replace("æ̞̈ːnʲ", "æ̞̃ːnʲ")
        .replace("ɞnʲ", "ɞ̃nʲ")
        .replace("ɔ̈nʲ", "ɔ̟̃nʲ")
        .replace("ɔ̈ːnʲ", "ɔ̟̃ːnʲ")
        .replace("ɜnʲ", "ɜ̃nʲ")
        .replace("ɛ̈nʲ", "ɛ̠̃nʲ")
        .replace("ɛ̈ːnʲ", "ɛ̠̃ːnʲ")
        .replace("enʲ", "ẽnʲ")
        .replace("eːnʲ", "ẽːnʲ")
        .replace("onʲ", "õnʲ")
        .replace("oːnʲ", "õːnʲ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("PASTO, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("PASTO, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Pasto" + reset + ", " + cyan + "CO" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// QUIBDÓ: IPA

pub fn spacoquibdo(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);
    let spaacc_i = spaaccent_i(&spaacc_o);
    let spaacc_u = spaaccent_u(&spaacc_i);

    let strmod = &spaacc_u
        .replace("ch", "ʈ͡ʂʲ")
        .replace("ce", "se")
        .replace("cé", "sé")
        .replace("ci", "si")
        .replace("cí", "sí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace('x', "ks")
        .replace('h', "")
        .replace('j', "ħ")
        .replace("ge", "ħe")
        .replace("gé", "ħé")
        .replace("gi", "ħi")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("ɾ#", "ɾ̥#")
        .replace("ɹ#", "ɹ̥#")
        .replace("y#", "i#")
        .replace('y', "ɟ͡ʝ")
        .replace("ll", "ɟ͡ʝ")
        .replace("lʈ͡ʂʲ", "lʲʈ͡ʂʲ")
        .replace("lt", "l̪t")
        .replace('b', "β̞")
        .replace("#β̞", "#β")
        .replace("mβ̞", "mβ")
        .replace("lβ̞", "lβ")
        .replace("l# #b", "l# #β")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ̞")
        .replace("lɣ̞", "lɣ")
        .replace("nɣ̞", "nɣ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("lð̞", "lð")
        .replace("áð̞a", "áʔa")
        .replace("áð̞o", "áʔo")
        .replace("óð̞a", "óʔa")
        .replace("óð̞o", "óʔo")
        .replace('z', "s")
        .replace("s#", "z̥#")
        .replace("sɣ", "s̬ɣ")
        .replace("sk", "s̬k")
        .replace("st", "h̥t")
        .replace("sɣ", "s̬ɣ")
        .replace("sð̞", "s̬ð̞")
        .replace("sm", "s̬m")
        .replace("sv", "s̬v")
        .replace("asá", "as̬á")
        .replace("asó", "as̬ó")
        .replace("asé", "as̬é")
        .replace("así", "as̬í")
        .replace("asú", "as̬ú")
        .replace("ása", "ás̬a")
        .replace("áso", "ás̬o")
        .replace("áse", "ás̬e")
        .replace("ási", "ás̬i")
        .replace("ásu", "ás̬u")
        .replace("osá", "os̬á")
        .replace("osó", "os̬ó")
        .replace("osé", "os̬é")
        .replace("osí", "os̬í")
        .replace("osú", "os̬ú")
        .replace("ósa", "ós̬a")
        .replace("óso", "ós̬o")
        .replace("óse", "ós̬e")
        .replace("ósi", "ós̬i")
        .replace("ósu", "ós̬u")
        .replace("esá", "es̬á")
        .replace("esó", "es̬ó")
        .replace("esé", "es̬é")
        .replace("esí", "es̬í")
        .replace("esú", "es̬ú")
        .replace("ésa", "és̬a")
        .replace("éso", "és̬o")
        .replace("ése", "és̬e")
        .replace("ési", "és̬i")
        .replace("ésu", "és̬u")
        .replace("isá", "is̬á")
        .replace("isó", "is̬ó")
        .replace("isé", "is̬é")
        .replace("isí", "is̬í")
        .replace("isú", "is̬ú")
        .replace("ísa", "ís̬a")
        .replace("íso", "ís̬o")
        .replace("íse", "ís̬e")
        .replace("ísi", "ís̬i")
        .replace("ísu", "ís̬u")
        .replace("usá", "us̬á")
        .replace("usó", "us̬ó")
        .replace("usé", "us̬é")
        .replace("usí", "us̬í")
        .replace("usú", "us̬ú")
        .replace("úsa", "ús̬a")
        .replace("úso", "ús̬o")
        .replace("úse", "ús̬e")
        .replace("úsi", "ús̬i")
        .replace("úsu", "ús̬u")
        .replace("ksse", "kse")
        .replace("kssi", "ksi")
        .replace('s', "s̻")
        .replace("s̻̬", "s̬")
        .replace("mn", "nn")
        .replace("nʈ͡ʂʲ", "nʲʈ͡ʂʲ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɣ", "ŋɣ")
        .replace("n#", "ŋ#")
        .replace("nm", "ɱ̥m")
        .replace("ŋ# #m", "ɱ# #m")
        .replace("ŋ# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("ŋ# #β", "ɱ# #β")
        .replace("np", "mp")
        .replace("ŋ# #p", "ɱ# #p")
        .replace('f', "ɸ")
        .replace("nɸ", "mɸ")
        .replace("ŋ# #ɸ", "ɱ# #f̟")
        .replace('ñ', "ɲ")
        .replace("ia", "ʲa")
        .replace("ie", "ʲe")
        .replace("io", "ʲo")
        .replace("iu", "ʲu")
        .replace("iá", "ʲá")
        .replace("ié", "ʲé")
        .replace("ió", "ʲó")
        .replace("iú", "ʲú")
        .replace("ea", "ia")
        .replace("eá", "iá")
        .replace("ká", "kɐ̠ˑ")
        .replace("ka", "kɐ̠")
        .replace('á', "ɐ̞ˑ")
        .replace('a', "ɐ")
        .replace('ó', "ɒˑ")
        .replace('o', "ɒ̝")
        .replace("mɒ̝#", "mɔ#")
        .replace("mɒ̝z̥#", "mɔz̥#")
        .replace("nʊ̈#", "nɔ#")
        .replace("nɒ̝z̥#", "nɔz̥#")
        .replace("ɲʊ̈#", "ɲɔ#")
        .replace("ɲɒ̝z̥#", "ɲɔz̥#")
        .replace("z̥# #s̻", "# #s̻")
        .replace('é', "ɛ̈ˑ")
        .replace('e', "ɜ")
        .replace('í', "iˑ")
        .replace('i', "i̞")
        .replace('ú', "uˑ")
        .replace('u', "u̞")
        .replace("mu̞", "mũ̞")
        .replace("ɒ̝ɱ̥m", "ɒ̝̃ɱ̥m")
        .replace("ɜɱ̥m", "ɜ̃ɱ̥m")
        .replace("i̞ɱ̥m", "ĩ̞ɱ̥m")
        .replace("u̞ɱ̥m", "ũ̞ɱ̥m")
        .replace("ɐnn", "ɐ̃nn")
        .replace("ɒ̝nn", "ɒ̝̃nn")
        .replace("ɜnn", "ɜ̃nn")
        .replace("i̞nn", "ĩ̞nn")
        .replace("i̞ˑnn", "ĩ̞ˑnn")
        .replace("u̞nn", "ũ̞nn")
        .replace("u̞ˑnn", "ũ̞ˑnn")
        .replace("ɐ̞ˑɱ", "ɐ̞̃ˑɱ")
        .replace("ɐ̞ɱ", "ɐ̞̃ɱ")
        .replace("ɒ̝ɱ", "ɒ̝̃ɱ")
        .replace("ɜɱ", "ɜ̃ɱ")
        .replace("ɐɱ", "ɐ̃ɱ")
        .replace("ɐ̠ɱ", "ɐ̠̃ɱ")
        .replace("ɐ̠ˑɱ", "ɐ̠̃ˑɱ")
        .replace("ɒˑɱ", "ɒ̃ˑɱ")
        .replace("ɛ̈ˑɱ", "ɛ̠̃ˑɱ")
        .replace("i̞ɱ", "ĩ̞ɱ")
        .replace("i̞ˑɱ", "ĩ̞ˑɱ")
        .replace("u̞ɱ", "ũ̞ɱ")
        .replace("u̞ˑɱ", "ũ̞ˑɱ")
        .replace("ɐ̞ˑŋ", "ɐ̞̃ˑŋ")
        .replace("ɒ̝ŋ", "ɒ̝̃ŋ")
        .replace("ɜŋ", "ɜ̃ŋ")
        .replace("ɐŋ", "ɐ̃ŋ")
        .replace("ɐ̠ŋ", "ɐ̠̃ŋ")
        .replace("ɐ̠ˑŋ", "ɐ̠̃ˑŋ")
        .replace("ɒˑŋ", "ɒ̃ˑŋ")
        .replace("ɛ̈ˑŋ", "ɛ̠̃ˑŋ")
        .replace("i̞ŋ", "ĩ̞ŋ")
        .replace("i̞ˑŋ", "ĩ̞ˑŋ")
        .replace("u̞ŋ", "ũ̞ŋ")
        .replace("u̞ˑŋ", "ũ̞ˑŋ")
        .replace("ɐ̞ˑn̪", "ɐ̞̃ˑn̪")
        .replace("ɐ̠n̪", "ɐ̠̃n̪")
        .replace("ɐ̠ˑn̪", "ɐ̠̃ˑn̪")
        .replace("ɒ̝n̪", "ɒ̝̃n̪")
        .replace("ɜn̪", "ɜ̃n̪")
        .replace("ɐn̪", "ɐ̃n̪")
        .replace("ɒˑn̪", "ɒ̃ˑn̪")
        .replace("ɛ̈ˑn̪", "ɛ̠̃ˑn̪")
        .replace("i̞n̪", "ĩ̞n̪")
        .replace("i̞ˑn̪", "ĩ̞ˑn̪")
        .replace("u̞n̪", "ũ̞n̪")
        .replace("u̞ˑn̪", "ũ̞ˑn̪")
        .replace("ɐnʲ", "ɐ̃nʲ")
        .replace("ɐ̞ˑnʲ", "ɐ̞̃ˑnʲ")
        .replace("ɐ̠nʲ", "ɐ̠̃nʲ")
        .replace("ɐ̠ˑnʲ", "ɐ̠̃ˑnʲ")
        .replace("ɒ̝nʲ", "ɒ̝̃nʲ")
        .replace("ɒˑnʲ", "ɒ̃ˑnʲ")
        .replace("ɜnʲ", "ɜ̃nʲ")
        .replace("ɛ̈ˑnʲ", "ɛ̠̃ˑnʲ")
        .replace("i̞nʲ", "ĩ̞nʲ")
        .replace("i̞ˑnʲ", "ĩ̞ˑnʲ")
        .replace("u̞nʲ", "ũ̞nʲ")
        .replace("u̞ˑnʲ", "ũ̞ˑnʲ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("QUIBDÓ, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("QUIBDÓ, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Quibdó" + reset + ", " + cyan + "CO" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// SANTA MARTA: IPA

pub fn spacosantamarta(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);

    let strmod = &spaacc_o
        .replace("ch", "t͡ʃ")
        .replace("ce", "se")
        .replace("cé", "sé")
        .replace("ci", "si")
        .replace("cí", "sí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace("ké", "kɜ")
        .replace("ke", "kɜ")
        .replace("kó", "kɞ")
        .replace("ko", "kɞ")
        .replace('x', "ks")
        .replace('h', "")
        .replace('j', "h")
        .replace("ge", "he")
        .replace("gé", "hé")
        .replace("gi", "hi")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("ɾ#", "ɾ̥#")
        .replace("ɹ#", "ɹ̥#")
        .replace("y#", "i#")
        .replace('y', "j")
        .replace("ll", "j")
        .replace("lt͡ʃ", "lʲt͡ʃ")
        .replace("lt", "l̪t")
        .replace('b', "β̞")
        .replace("#β̞", "#β")
        .replace("mβ̞", "mβ")
        .replace("lβ̞", "lβ")
        .replace("l# #b", "l# #β")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ̞")
        .replace("lɣ̞", "lɣ")
        .replace("nɣ̞", "nɣ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("lð̞", "lð")
        .replace("áð̞a", "áʔa")
        .replace("áð̞o", "áʔo")
        .replace("óð̞a", "óʔa")
        .replace("óð̞o", "óʔo")
        .replace('z', "s")
        .replace("s#", "h̥#")
        .replace("sk", "h̥k")
        .replace("st", "h̥t")
        .replace("ksse", "kse")
        .replace("kssi", "ksi")
        .replace('s', "s̻")
        .replace("mn", "nn")
        .replace("nt͡ʃ", "nʲt͡ʃ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɣ", "ŋɣ")
        .replace("n#", "ŋ#")
        .replace("nm", "ɱ̥m")
        .replace("ŋ# #m", "ɱ# #m")
        .replace("ŋ# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("ŋ# #β", "ɱ# #β")
        .replace("np", "mp")
        .replace("ŋ# #p", "ɱ# #p")
        .replace("nf", "mf")
        .replace("ŋ# #f", "ɱ# #f")
        .replace('ñ', "ɲ")
        .replace("ia", "ja")
        .replace("ie", "je")
        .replace("io", "jo")
        .replace("iu", "ju")
        .replace("iá", "já")
        .replace("ié", "jé")
        .replace("ió", "jó")
        .replace("iú", "jú")
        .replace("ea", "ia")
        .replace("eá", "iá")
        .replace("ká", "kɐ")
        .replace("ka", "kɐ")
        .replace('k', "k̬")
        .replace('á', "æ̞̈")
        .replace('a', "æ̈")
        .replace('ó', "ɞ")
        .replace("o#", "ʊ̈#")
        .replace("oh̥#", "ʊ̈h̥#")
        .replace('o', "ɞ̝")
        .replace("lʊ̈#", "lo̞#")
        .replace("lʊ̈h̥#", "lo̞h̥#")
        .replace("ɾʊ̈#", "ɾo̞#")
        .replace("ɾʊ̈h̥#", "ɾo̞h̥#")
        .replace("mʊ̈#", "mo̽#")
        .replace("mʊ̈h̥#", "mo̽h̥#")
        .replace("nʊ̈#", "no̽#")
        .replace("nʊ̈h̥#", "no̽h̥#")
        .replace("ɲʊ̈#", "ɲo̽#")
        .replace("ɲʊ̈h̥#", "ɲo̽h̥#")
        .replace('é', "ɜ")
        .replace('e', "ɜ̝")
        .replace('í', "i")
        .replace('i', "ɪ")
        .replace('ú', "u")
        .replace('u', "ʊ")
        .replace("mʊ", "mʊ̃")
        .replace("mɞ̝", "mɞ̝̃")
        .replace("ɞɱ̥m", "ɞ̃ɱ̥m")
        .replace("ɜ̝ɱ̥m", "ɜ̝̃ɱ̥m")
        .replace("ɪɱ̥m", "ɪ̃ɱ̥m")
        .replace("ʊɱ̥m", "ʊ̃ɱ̥m")
        .replace("æ̈nn", "æ̠̃nn")
        .replace("ɞ̝nn", "ɞ̝̃nn")
        .replace("ɜ̝nn", "ɜ̝̃nn")
        .replace("ɪnn", "ɪ̃nn")
        .replace("ʊnn", "ʊ̃nn")
        .replace("æ̞̈ɱ", "æ̞̃ɱ")
        .replace("ɞ̝ɱ", "ɞ̝̃ɱ")
        .replace("ɜ̝ɱ", "ɜ̝̃ɱ")
        .replace("æ̈ɱ", "æ̠̃ɱ")
        .replace("ɐɱ", "ɐ̃ɱ")
        .replace("ɞɱ", "ɞ̃ɱ")
        .replace("ɜɱ", "ɜ̃ɱ")
        .replace("ɪɱ", "ɪ̃ɱ")
        .replace("ʊɱ", "ʊ̃ɱ")
        .replace("æ̞̈ŋ", "æ̞̃ŋ")
        .replace("ɞ̝ŋ", "ɞ̝̃ŋ")
        .replace("ɜ̝ŋ", "ɜ̝̃ŋ")
        .replace("æ̈ŋ", "æ̠̃ŋ")
        .replace("ɐŋ", "ɐ̃ŋ")
        .replace("ɞŋ", "ɞ̃ŋ")
        .replace("ɜŋ", "ɜ̃ŋ")
        .replace("ɪŋ", "ɪ̃ŋ")
        .replace("ʊŋ", "ʊ̃ŋ")
        .replace("æ̞̈n̪", "æ̞̃n̪")
        .replace("ɐn̪", "ɐ̃n̪")
        .replace("ɞ̝n̪", "ɞ̝̃n̪")
        .replace("ɜ̝n̪", "ɜ̝̃n̪")
        .replace("æ̈n̪", "æ̠̃n̪")
        .replace("ɞn̪", "ɞ̃n̪")
        .replace("ɜn̪", "ɜ̃n̪")
        .replace("ɪn̪", "ɪ̃n̪")
        .replace("ʊn̪", "ʊ̃n̪")
        .replace("æ̈nʲ", "æ̠̃nʲ")
        .replace("æ̞̈nʲ", "æ̞̃nʲ")
        .replace("ɐnʲ", "ɐ̃nʲ")
        .replace("ɞ̝nʲ", "ɞ̝̃nʲ")
        .replace("ɞnʲ", "ɞ̃nʲ")
        .replace("ɜ̝nʲ", "ɜ̝̃nʲ")
        .replace("ɜnʲ", "ɜ̃nʲ")
        .replace("ɪnʲ", "ɪ̃nʲ")
        .replace("ʊnʲ", "ʊ̃nʲ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("SANTA MARTA, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("SANTA MARTA, CO:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Santa Marta" + reset + ", " + cyan + "CO" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// BILBAO: IPA

pub fn spaesbilbao(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);

    let strmod = &spaacc_o
        .replace("ch", "t͡ʃ")
        .replace("ce", "θe")
        .replace("cé", "θé")
        .replace("ci", "θi")
        .replace("cí", "θí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace('x', "ks")
        .replace('j', "x")
        .replace("ge", "xe")
        .replace("gé", "xé")
        .replace("gi", "χi")
        .replace("xi", "χi")
        .replace("ix", "iχ")
        .replace("xu", "χu")
        .replace("ux", "uχ")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("y#", "i#")
        .replace('y', "ʝ")
        .replace("ll", "ʝ")
        .replace("ld", "l̪d")
        .replace("lt͡ʃ", "lʲt͡ʃ")
        .replace("lt", "l̪t")
        .replace("lz", "l̟z")
        .replace("lk", "ʟk")
        .replace("lg", "ʟg")
        .replace("lx", "ʟx")
        .replace('b', "β̞")
        .replace("#β̞", "#β")
        .replace("mβ̞", "mβ")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ̞")
        .replace("nɣ̞", "nɣ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("l̪ð̞", "l̪ð")
        .replace('s', "s̺")
        .replace("s̺#", "s̬#")
        .replace("s̺ɣ̞", "s̬ɣ̞")
        .replace("s̺m", "s̬m")
        .replace("s̺v", "s̬v")
        .replace("s̺k", "s̬k")
        .replace("zɣ̞", "ðɣ̞")
        .replace('z', "θ")
        .replace("s̺θ", "s̺")
        .replace("ks̺θ", "ks̺")
        .replace("mn", "nn")
        .replace("nt͡ʃ", "nʲt͡ʃ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɣ", "ŋɣ")
        .replace("nx", "ŋx")
        .replace("nθ", "n̟θ")
        .replace("nχ", "ɴχ")
        .replace("n#", "ŋ#")
        .replace("nm", "ɱ̥m")
        .replace("ŋ# #m", "ɱ# #m")
        .replace("ŋ# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("ŋ# #β", "ɱ# #β")
        .replace("np", "mp")
        .replace("ŋ# #p", "ɱ# #p")
        .replace("nf", "mf")
        .replace("ŋ# #f", "ɱ# #f")
        .replace('ñ', "ɲ")
        .replace('h', "")
        .replace("ia", "ʲa")
        .replace("ie", "ʲe")
        .replace("io", "ʲo")
        .replace("iu", "ʲu")
        .replace("iá", "ʲá")
        .replace("ié", "ʲé")
        .replace("ió", "ʲó")
        .replace("iú", "ʲú")
        .replace('á', "ɐ")
        .replace('a', "ɐ̝")
        .replace("ʝɐ̞", "ɟ͡ʝɐ̞")
        .replace('ó', "ɔ̈")
        .replace('o', "ə̠")
        .replace('é', "ɛ̈")
        .replace('e', "ə̟")
        .replace('í', "i")
        .replace('i', "e")
        .replace('ú', "u")
        .replace('u', "o")
        .replace("mo", "mõ")
        .replace("ə̠ɱ̥m", "ə̠̃ɱ̥m")
        .replace("ə̟ɱ̥m", "ə̟̃ɱ̥m")
        .replace("eɱ̥m", "ẽɱ̥m")
        .replace("oɱ̥m", "õɱ̥m")
        .replace("ɐ̝nn", "ɐ̝̃nn")
        .replace("ə̠nn", "ə̠̃nn")
        .replace("ə̟nn", "ə̟̃nn")
        .replace("enn", "ẽnn")
        .replace("onn", "õnn")
        .replace("ɐɱ", "ɐ̃ɱ")
        .replace("ə̠ɱ", "ə̠̃ɱ")
        .replace("ə̟ɱ", "ə̟̃ɱ")
        .replace("ɐ̝ɱ", "ɐ̝̃ɱ")
        .replace("ɔ̈ɱ", "ɞ̃ɱ")
        .replace("ɛ̈ɱ", "ɜ̃ɱ")
        .replace("eɱ", "ẽɱ")
        .replace("oɱ", "õɱ")
        .replace("ɐŋ", "ɐ̃ŋ")
        .replace("ə̠ŋ", "ə̠̃ŋ")
        .replace("ə̟ŋ", "ə̟̃ŋ")
        .replace("ɐ̝ŋ", "ɐ̝̃ŋ")
        .replace("ɔ̈ŋ", "ɞ̃ŋ")
        .replace("ɛ̈ŋ", "ɜ̃ŋ")
        .replace("eŋ", "ẽŋ")
        .replace("oŋ", "õŋ")
        .replace("ɐn̪", "ɐ̃n̪")
        .replace("ə̠n̪", "ə̠̃n̪")
        .replace("ə̟n̪", "ə̟̃n̪")
        .replace("ɐ̝n̪", "ɐ̝̃n̪")
        .replace("ɔ̈n̪", "ɞ̃n̪")
        .replace("ɛ̈n̪", "ɜ̃n̪")
        .replace("en̪", "ẽn̪")
        .replace("on̪", "õn̪")
        .replace("ɐnʲ", "ɐ̃nʲ")
        .replace("ə̠nʲ", "ə̠̃nʲ")
        .replace("ə̟nʲ", "ə̟̃nʲ")
        .replace("ɐ̝nʲ", "ɐ̝̃nʲ")
        .replace("ɔ̈nʲ", "ɞ̃nʲ")
        .replace("ɛ̈nʲ", "ɜ̃nʲ")
        .replace("enʲ", "ẽnʲ")
        .replace("onʲ", "õnʲ")
        .replace("ɐn̟", "ɐ̃n̟")
        .replace("ə̠n̟", "ə̠̃n̟")
        .replace("ə̟n̟", "ə̟̃n̟")
        .replace("ɐ̝n̟", "ɐ̝̃n̟")
        .replace("ɔ̈n̟", "ɞ̃n̟")
        .replace("ɛ̈n̟", "ɜ̃n̟")
        .replace("en̟", "ẽn̟")
        .replace("on̟", "õn̟")
        .replace("ɐɴ", "ɐ̃ɴ")
        .replace("ə̠ɴ", "ə̠̃ɴ")
        .replace("ə̟ɴ", "ə̟̃ɴ")
        .replace("ɐ̝ɴ", "ɐ̝̃ɴ")
        .replace("ɔ̈ɴ", "ɞ̃ɴ")
        .replace("ɛ̈ɴ", "ɜ̃ɴ")
        .replace("eɴ", "ẽɴ")
        .replace("oɴ", "õɴ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("BILBAO, ES:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("BILBAO, ES:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Bilbao" + reset + ", " + cyan + "ES" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// CÁDIZ: IPA

pub fn spaescadiz(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);

    let strmod = &spaacc_o
        .replace("ch", "ʃʲ")
        .replace("ce", "se")
        .replace("cé", "sé")
        .replace("ci", "si")
        .replace("cí", "sí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace('x', "ks")
        .replace('h', "h^")
        .replace("#h^", "#h̥")
        .replace("h^", "")
        .replace('j', "x")
        .replace("ge", "xe")
        .replace("gé", "xé")
        .replace("gi", "xi")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("y#", "i#")
        .replace('y', "ʝ")
        .replace("ll", "ʝ")
        .replace("lʃʲ", "lʲʃʲ")
        .replace("lt", "l̪t")
        .replace('b', "β̞")
        .replace("#β̞", "#β")
        .replace("mβ̞", "mβ")
        .replace("lβ̞", "lβ")
        .replace("l# #b", "l# #β")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ̞")
        .replace("lɣ̞", "lɣ")
        .replace("nɣ̞", "nɣ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("lð̞", "lð")
        .replace("áð̞o#", "að̥o#")
        .replace("ið̞a#", "iʔa#")
        .replace("ið̞o#", "iʔo#")
        .replace("#iʔo#", "#ið̞o#")
        .replace("ð̞ita", "ʔita")
        .replace("ð̞ito", "ʔito")
        .replace('z', "s")
        .replace('s', "s̻")
        .replace("#es̻#", "#es̬#")
        .replace("s̻#", "#")
        .replace("s̻k", "s̥k")
        .replace("s̻t", "s̥t")
        .replace("as̻o", "as̬o")
        .replace("as̻ó", "as̬ó")
        .replace("ás̻o", "ás̬o")
        .replace("os̻o", "os̬o")
        .replace("os̻ó", "os̬ó")
        .replace("ós̻o", "ós̬o")
        .replace("es̻o", "es̬o")
        .replace("es̻ó", "es̬ó")
        .replace("és̻o", "és̬o")
        .replace("is̻o", "is̬o")
        .replace("is̻ó", "is̬ó")
        .replace("ís̻o", "ís̬o")
        .replace("us̻o", "us̬o")
        .replace("us̻ó", "us̬ó")
        .replace("ús̻o", "ús̬o")
        .replace("ks̻s̻e", "ks̻e")
        .replace("ks̻s̻i", "ks̻i")
        .replace("mn", "nn")
        .replace("nʈ͡ʂʲ", "nʲʈ͡ʂʲ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɣ", "ŋɣ")
        .replace("nx", "ŋx")
        .replace("n#", "ŋ#")
        .replace("nm", "ɱ̥m")
        .replace("ŋ# #m", "ɱ# #m")
        .replace("ŋ# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("ŋ# #β", "ɱ# #β")
        .replace("np", "mp")
        .replace("ŋ# #p", "ɱ# #p")
        .replace("nf", "mf")
        .replace("ŋ# #f", "ɱ# #f")
        .replace('ñ', "ɲ")
        .replace('f', "f̟")
        .replace('k', "k̬")
        .replace("ia", "ja")
        .replace("ie", "je")
        .replace("io", "jo")
        .replace("iu", "ju")
        .replace("iá", "já")
        .replace("ié", "jé")
        .replace("ió", "jó")
        .replace("iú", "jú")
        .replace('á', "ɐ")
        .replace('a', "ɐ̝")
        .replace('ó', "ɞ̠")
        .replace('o', "ɞ")
        .replace('é', "ɜ̟")
        .replace('e', "ɜ")
        .replace('í', "i")
        .replace('i', "ɪ")
        .replace('ú', "u")
        .replace('u', "ʊ")
        .replace("mɞ#", "mɔ̽#")
        .replace("nɞ#", "nɔ̽#")
        .replace("ɲɞ#", "ɲɔ̽#")
        .replace("mʊ", "mʊ̃")
        .replace("ɞɱ̥m", "ɞ̃ɱ̥m")
        .replace("ɜɱ̥m", "ɜ̃ɱ̥m")
        .replace("ɪɱ̥m", "ɪ̃ɱ̥m")
        .replace("ʊɱ̥m", "ʊ̃ɱ̥m")
        .replace("ɐ̝nn", "ɐ̝̃nn")
        .replace("ɞnn", "ɞ̃nn")
        .replace("ɜnn", "ɜ̃nn")
        .replace("ɪnn", "ɪ̃nn")
        .replace("ʊnn", "ʊ̃nn")
        .replace("ɐɱ", "ɐ̃ɱ")
        .replace("ɞɱ", "ɞ̃ɱ")
        .replace("ɜɱ", "ɜ̃ɱ")
        .replace("ɐ̝ɱ", "ɐ̝̃ɱ")
        .replace("ɞ̠ɱ", "ɞ̠̃ɱ")
        .replace("ɜ̟ɱ", "ɜ̟̃ɱ")
        .replace("ɪɱ", "ɪ̃ɱ")
        .replace("ʊɱ", "ʊ̃ɱ")
        .replace("ɐŋ", "ɐ̃ŋ")
        .replace("ɞŋ", "ɞ̃ŋ")
        .replace("ɜŋ", "ɜ̃ŋ")
        .replace("ɐ̝ŋ", "ɐ̝̃ŋ")
        .replace("ɞ̠ŋ", "ɞ̠̃ŋ")
        .replace("ɜ̟ŋ", "ɜ̟̃ŋ")
        .replace("ɪŋ", "ɪ̃ŋ")
        .replace("ʊŋ", "ʊ̃ŋ")
        .replace("ɐn̪", "ɐ̃n̪")
        .replace("ɞn̪", "ɞ̃n̪")
        .replace("ɜn̪", "ɜ̃n̪")
        .replace("ɐ̝n̪", "ɐ̝̃n̪")
        .replace("ɞ̠n̪", "ɞ̠̃n̪")
        .replace("ɜ̟n̪", "ɜ̟̃n̪")
        .replace("ɪn̪", "ɪ̃n̪")
        .replace("ʊn̪", "ʊ̃n̪")
        .replace("ɐ̝nʲ", "ɐ̝̃nʲ")
        .replace("ɐnʲ", "ɐ̃nʲ")
        .replace("ɞnʲ", "ɞ̃nʲ")
        .replace("ɞ̠nʲ", "ɞ̠̃nʲ")
        .replace("ɜnʲ", "ɜ̃nʲ")
        .replace("ɜ̟nʲ", "ɜ̟̃nʲ")
        .replace("ɪnʲ", "ɪ̃nʲ")
        .replace("ʊnʲ", "ʊ̃nʲ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("CÁDIZ, ES:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("CÁDIZ, ES:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Cádiz" + reset + ", " + cyan + "ES" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// MADRID: IPA

pub fn spaesmadrid(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);

    let strmod = &spaacc_o
        .replace("ch", "t͡ʃ")
        .replace("ce", "θe")
        .replace("cé", "θé")
        .replace("ci", "θi")
        .replace("cí", "θí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace('x', "ks")
        .replace('j', "x")
        .replace("ge", "xe")
        .replace("gé", "xé")
        .replace("gi", "χi")
        .replace("xi", "χi")
        .replace("ix", "iχ")
        .replace("xu", "χu")
        .replace("ux", "uχ")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("y#", "i#")
        .replace('y', "ʝ")
        .replace("ll", "j")
        .replace("ld", "l̪d")
        .replace("lt͡ʃ", "lʲt͡ʃ")
        .replace("lt", "l̪t")
        .replace("lz", "l̟z")
        .replace("lk", "ʟk")
        .replace("lg", "ʟg")
        .replace("lx", "ʟx")
        .replace('b', "β̞")
        .replace("#β̞", "#β")
        .replace("mβ̞", "mβ")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ̞")
        .replace("nɣ̞", "nɣ")
        .replace("ád#", "á#")
        .replace("id#", "iθ#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("l̪ð̞", "l̪ð")
        .replace('s', "s̺")
        .replace("s̺#", "s̬#")
        .replace("s̺ɣ̞", "s̬ɣ̞")
        .replace("s̺m", "s̬m")
        .replace("s̺v", "s̬v")
        .replace("s̺k", "xk")
        .replace("s̬# #k", "x# #k")
        .replace("zɣ̞", "ðɣ̞")
        .replace('z', "θ")
        .replace("s̺θ", "s̺")
        .replace("ks̺θ", "ks̺")
        .replace("mn", "nn")
        .replace("nt͡ʃ", "nʲt͡ʃ")
        .replace('t', "t̪")
        .replace("nt̪", "n̪t̪")
        .replace("nð", "n̪ð")
        .replace("nk", "ŋk")
        .replace("nɣ", "ŋɣ")
        .replace("nx", "ŋx")
        .replace("nθ", "n̟θ")
        .replace("nχ", "ɴχ")
        .replace("nm", "ɱ̥m")
        .replace("n# #m", "m# #m")
        .replace("n# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("n# #β", "m# #β")
        .replace("np", "mp")
        .replace("n# #p", "m# #p")
        .replace("nf", "ɱf")
        .replace("n# #f", "ɱ# #f")
        .replace('ñ', "ɲ")
        .replace('h', "")
        .replace("ia", "ja")
        .replace("ie", "je")
        .replace("io", "jo")
        .replace("iu", "ju")
        .replace("iá", "já")
        .replace("ié", "jé")
        .replace("ió", "jó")
        .replace("iú", "jú")
        .replace('á', "ɐ̞")
        .replace('a', "ɐ")
        .replace("ʝɐ̞", "ɟ͡ʝɐ̞")
        .replace('ó', "ɔ")
        .replace('o', "ɔ̝")
        .replace('é', "ɛ")
        .replace('e', "ɛ̝")
        .replace('í', "i")
        .replace('i', "i̞")
        .replace('ú', "u")
        .replace('u', "u̞")
        .replace("ɔn", "ɔ̃n")
        .replace("ɔm#", "ɔ̃m#")
        .replace("mu̞", "mũ̞")
        .replace("ɔ̝ɱ̥m", "ɔ̝̃ɱ̥m")
        .replace("ɛ̝ɱ̥m", "ɛ̝̃ɱ̥m")
        .replace("i̞ɱ̥m", "ĩ̞ɱ̥m")
        .replace("u̞ɱ̥m", "ũ̞ɱ̥m")
        .replace("ɐnn", "ɐ̃nn")
        .replace("ɔ̝nn", "ɔ̝̃nn")
        .replace("ɛ̝nn", "ɛ̝̃nn")
        .replace("i̞nn", "ĩ̞nn")
        .replace("u̞nn", "ũ̞nn")
        .replace("ɐ̞ɱ", "ɐ̞̃ɱ")
        .replace("ɔ̝ɱ", "ɔ̝̃ɱ")
        .replace("ɛ̝ɱ", "ɛ̝̃ɱ")
        .replace("ɐɱ", "ɐ̃ɱ")
        .replace("ɔɱ", "ɔ̃ɱ")
        .replace("ɛɱ", "ɛ̃ɱ")
        .replace("i̞ɱ", "ĩ̞ɱ")
        .replace("u̞ɱ", "ũ̞ɱ")
        .replace("ɐ̞ŋ", "ɐ̞̃ŋ")
        .replace("ɔ̝ŋ", "ɔ̝̃ŋ")
        .replace("ɛ̝ŋ", "ɛ̝̃ŋ")
        .replace("ɐŋ", "ɐ̃ŋ")
        .replace("ɔŋ", "ɔ̃ŋ")
        .replace("ɛŋ", "ɛ̃ŋ")
        .replace("i̞ŋ", "ĩ̞ŋ")
        .replace("u̞ŋ", "ũ̞ŋ")
        .replace("ɐ̞n̪", "ɐ̞̃n̪")
        .replace("ɔ̝n̪", "ɔ̝̃n̪")
        .replace("ɛ̝n̪", "ɛ̝̃n̪")
        .replace("ɐn̪", "ɐ̃n̪")
        .replace("ɔn̪", "ɔ̃n̪")
        .replace("ɛn̪", "ɛ̃n̪")
        .replace("i̞n̪", "ĩ̞n̪")
        .replace("u̞n̪", "ũ̞n̪")
        .replace("ɐ̞nʲ", "ɐ̞̃nʲ")
        .replace("ɔ̝nʲ", "ɔ̝̃nʲ")
        .replace("ɛ̝nʲ", "ɛ̝̃nʲ")
        .replace("ɐnʲ", "ɐ̃nʲ")
        .replace("ɔnʲ", "ɔ̃nʲ")
        .replace("ɛnʲ", "ɛ̃nʲ")
        .replace("i̞nʲ", "ĩ̞nʲ")
        .replace("u̞nʲ", "ũ̞nʲ")
        .replace("ɐ̞n̟", "ɐ̞̃n̟")
        .replace("ɔ̝n̟", "ɔ̝̃n̟")
        .replace("ɛ̝n̟", "ɛ̝̃n̟")
        .replace("ɐn̟", "ɐ̃n̟")
        .replace("ɔn̟", "ɔ̃n̟")
        .replace("ɛn̟", "ɛ̃n̟")
        .replace("i̞n̟", "ĩ̞n̟")
        .replace("u̞n̟", "ũ̞n̟")
        .replace("ɐ̞ɴ", "ɐ̞̃ɴ")
        .replace("ɔ̝ɴ", "ɔ̝̃ɴ")
        .replace("ɛ̝ɴ", "ɛ̝̃ɴ")
        .replace("ɐɴ", "ɐ̃ɴ")
        .replace("ɔɴ", "ɔ̃ɴ")
        .replace("ɛɴ", "ɛ̃ɴ")
        .replace("i̞ɴ", "ĩ̞ɴ")
        .replace("u̞ɴ", "ũ̞ɴ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("MADRID, ES:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("MADRID, ES:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Madrid" + reset + ", " + cyan + "ES" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}

//   ++++++++++   ++++++++++   ++++++++++

// CIUDAD DE MÉXICO: IPA

pub fn spamxciudaddemexico(original_text: &str, usefile: &str, outputfile: &str, reset: &str, red: &str, cyan: &str, yellow: &str) {
    let dotend = original_text.to_owned() + ".";
    let dotbeg = ".".to_owned() + &dotend;
    let lowercase = &dotbeg.to_lowercase();
    let pncbeg = spapncbeg(lowercase);
    let palesp = spapalesp(&pncbeg);

    let spaacc_a = spaaccent_a(&palesp);
    let spaacc_e = spaaccent_e(&spaacc_a);
    let spaacc_o = spaaccent_o(&spaacc_e);

    let strmod = &spaacc_o
        .replace("ch", "t͡ʃ")
        .replace("ce", "ɬe")
        .replace("cé", "ɬé")
        .replace("ci", "ɬi")
        .replace("cí", "ɬí")
        .replace('c', "k")
        .replace("que", "ke")
        .replace("qué", "ké")
        .replace("qui", "ki")
        .replace('q', "k")
        .replace('x', "ks")
        .replace('j', "x")
        .replace("ge", "xe")
        .replace("gé", "xé")
        .replace("gi", "χi")
        .replace("xi", "χi")
        .replace("ix", "iχ")
        .replace("xu", "χu")
        .replace("ux", "uχ")
        .replace('r', "ɾ")
        .replace("subɾ", "subr")
        .replace("abɾ", "abr")
        .replace("nɾ", "nr")
        .replace("lɾ", "lr")
        .replace("sɾ", "sr")
        .replace("#ɾ", "#r")
        .replace("ɾɾ", "r")
        .replace("oɾ", "oɹ")
        .replace("ór", "óɹ")
        .replace("y#", "i#")
        .replace('y', "ʝ")
        .replace("ll", "ʝ")
        .replace("lt͡ʃ", "lʲt͡ʃ")
        .replace("lk", "ʟk")
        .replace("lg", "ʟg")
        .replace("lx", "ʟx")
        .replace('b', "β̞")
        .replace("#β̞", "#β")
        .replace("mβ̞", "mβ")
        .replace('v', "β̞")
        .replace("fg", "vg")
        .replace("fn", "vn")
        .replace("gue", "ge")
        .replace("gué", "gé")
        .replace("gui", "gi")
        .replace("guí", "gí")
        .replace('ü', "u")
        .replace('g', "ɣ̞")
        .replace("nɣ̞", "nɣ")
        .replace("ád#", "á#")
        .replace("id#", "i#")
        .replace('d', "ð̞")
        .replace("#ð̞", "#ð")
        .replace("nð̞", "nð")
        .replace("lð̞", "lð")
        .replace('l', "l̠")
        .replace(['z', 's'], "ɬ")
        .replace("ɬ#", "ɬ̬#")
        .replace("ɬɣ̞", "ɬ̬ɣ̞")
        .replace("ɬk", "ɬ̬k")
        .replace("ɬð̞", "ɬ̬ð̞")
        .replace("ɬm", "ɬ̬m")
        .replace("ɬv", "ɬ̬v")
        .replace("kɬɬe", "kɬe")
        .replace("kɬɬi", "kɬi")
        .replace('ɬ', "ɬ̻")
        .replace("ɬ̻̬", "ɬ̬")
        .replace("mn", "nn")
        .replace("nt͡ʃ", "nʲt͡ʃ")
        .replace("nk", "ŋk")
        .replace("nɣ", "ŋɣ")
        .replace("nx", "ŋx")
        .replace("nχ", "ɴχ")
        .replace("nm", "ŋm")
        .replace("n# #m", "ŋ# #m")
        .replace("n# #n", "ɱ# #n")
        .replace("nβ", "mβ")
        .replace("n# #β", "m# #β")
        .replace("np", "mp")
        .replace("n# #p", "m# #p")
        .replace("nf", "ɱf")
        .replace("n# #f", "ɱ# #f")
        .replace('ñ', "ɲ")
        .replace('h', "")
        .replace("ia", "ʲa")
        .replace("ie", "ʲe")
        .replace("io", "ʲo")
        .replace("iu", "ʲu")
        .replace("iá", "ʲá")
        .replace("ié", "ʲé")
        .replace("ió", "ʲó")
        .replace("iú", "ʲú")
        .replace('á', "ʌ̞")
        .replace('a', "ʌ")
        .replace('ó', "ɔ̈")
        .replace('o', "ɔ̽")
        .replace('é', "ɛ̈")
        .replace('e', "ɛ̽")
        .replace('í', "i")
        .replace('i', "ɪ")
        .replace('ú', "u")
        .replace('u', "ʊ")
        .replace("ɔ̈n", "ɔ̃n")
        .replace("ɔ̈m#", "ɔ̃m#")
        .replace("mʊ", "mʊ̃")
        .replace("ʌnn", "ʌ̃nn")
        .replace("ɔ̽nn", "ɔ̝̃nn")
        .replace("ɛ̽nn", "ɛ̝̃nn")
        .replace("ɪnn", "ɪ̃nn")
        .replace("ʊnn", "ʊ̃nn")
        .replace("ʌ̞ɱ", "ʌ̞̃ɱ")
        .replace("ɔ̽ɱ", "ɔ̝̃ɱ")
        .replace("ɛ̽ɱ", "ɛ̝̃ɱ")
        .replace("ʌɱ", "ʌ̃ɱ")
        .replace("ɔ̈ɱ", "ɔ̃ɱ")
        .replace("ɛ̈ɱ", "ɛ̃ɱ")
        .replace("ɪɱ", "ɪ̃ɱ")
        .replace("ʊɱ", "ʊ̃ɱ")
        .replace("ʌ̞ŋ", "ʌ̞̃ŋ")
        .replace("ɔ̽ŋ", "ɔ̝̃ŋ")
        .replace("ɛ̽ŋ", "ɛ̝̃ŋ")
        .replace("ʌŋ", "ʌ̃ŋ")
        .replace("ɔ̈ŋ", "ɔ̃ŋ")
        .replace("ɛ̈ŋ", "ɛ̃ŋ")
        .replace("ɪŋ", "ɪ̃ŋ")
        .replace("ʊŋ", "ʊ̃ŋ")
        .replace("ʌ̞nʲ", "ʌ̞̃nʲ")
        .replace("ɔ̽nʲ", "ɔ̝̃nʲ")
        .replace("ɛ̽nʲ", "ɛ̝̃nʲ")
        .replace("ʌnʲ", "ʌ̃nʲ")
        .replace("ɔ̈nʲ", "ɔ̃nʲ")
        .replace("ɛ̈nʲ", "ɛ̃nʲ")
        .replace("ɪnʲ", "ɪ̃nʲ")
        .replace("ʊnʲ", "ʊ̃nʲ")
        .replace("ʌ̞ɴ", "ʌ̞̃ɴ")
        .replace("ɔ̽ɴ", "ɔ̝̃ɴ")
        .replace("ɛ̽ɴ", "ɛ̝̃ɴ")
        .replace("ʌɴ", "ʌ̃ɴ")
        .replace("ɔ̈ɴ", "ɔ̃ɴ")
        .replace("ɛ̈ɴ", "ɛ̃ɴ")
        .replace("ɪɴ", "ɪ̃ɴ")
        .replace("ʊɴ", "ʊ̃ɴ");

    let result = spapncend(strmod);

    if usefile == "new" {
        let mut file = std::fs::File::create(outputfile).expect(&(red.to_owned() + "The output file could not be created!" + reset));
        file.write_all("CIUDAD DE MÉXICO, MX:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "old" {
        let mut file = OpenOptions::new().append(true).open(outputfile).expect(&(red.to_owned() + "cannot open file" + reset));
        file.write_all("CIUDAD DE MÉXICO, MX:".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all(result.as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
        file.write_all("\n".as_bytes()).expect(&(red.to_owned() + "write failed" + reset));
    }
    if usefile == "terminal" {
        println!();
        println!("{}", cyan.to_owned() + "Ciudad de México" + reset + ", " + cyan + "MX" + reset + ":");
        println!();
        print!("{}", yellow);
        println!("{}", result);
        print!("{}", reset);
    }
}