var hdnquerygrammar = `
Expression 
	= head:((_)?"("(_)?("AND "/"OR ") Filtro+ (_)?(")")?){return '{"'+head[3]+'": ['+head[4]+"]}"}//{ return head}.join("").replaceAll(", ,","").replaceAll("(,","(").replaceAll(",("," (")}
	/ resu:Filtro {return resu[1].split().join()+' ';}
Filtro
	= (_)"("?head:(("AND "/"OR "))? tail:(Clausola+ / Filtronick+) (_)? closecl:(")")?
    			
    		{if (head != null) return ' {"'+head+'":['+tail+"]}";
            else if (tail!=null & tail.length <2) return ' '+tail+''
            	  else return ""+tail+"";}
			/ cl:Clausola 

Clausola
	= cla:("Clausola"Integer)(_)? {return ' {"TERM": "'+cla[0]+cla[1]+'"}';}
    
Filtronick
	=fil:("filtro-"Integer)(_)? {return ' {"TERM": "'+fil[0]+fil[1]+'"}';}


Integer "integer"
  = _ [0-9]+ { return parseInt(text(), 10); }

_ "whitespace"= " "*

`



var testmm = 0



var ontoSparqlQuerySynt = `
PREFIX ecrm: <http://erlangen-crm.org/current/>
PREFIX orl: <https://dantenetwork.it/ontology/orl/current/>
PREFIX ontolex: <http://www.w3.org/ns/lemon/ontolex#>
PREFIX olires: <https://dantenetwork.it/ontology/olires/current/>
PREFIX syntit: <https://dantenetwork.it/ontology/syntit/current/>
SELECT DISTINCT ?sentence  ?clocc ?clfr ?clto  ?clafunction ?clatype (?t_canto as ?Canto) (?t_cantica as ?Cantica)
WHERE {
  FILTER regex(?Rappresentazione,"^persona$","i") . #remove if query_text==''
  FILTER langMatches(lang(?Rappresentazione),"it") #remove if query_text==''
  ?cat ontolex:writtenRep ?Rappresentazione . #remove if query_text==''
  ?lent ontolex:lexicalForm ?cat; #remove if query_text==''
      ontolex:canonicalForm ?cf. #remove if query_text==''
  ?cf ontolex:writtenRep ?lm. #remove if query_text==''
  ?fa olires:occurrenceOf ?cat . #remove if query_text==''
  ?clocc ecrm:P148_has_component ?fa . #remove if query_text==''
  ?cl syntit:hasClauseType ?clatype;
    ecrm:P190_has_symbolic_content ?cltext;
    syntit:hasClauseFunction ?clafunction.
  ?clocc olires:occurrenceOf ?cl;
    olires:occursInRegion ?frag.
  ?frag olires:fragmentRegionFrom ?clfr;
    olires:fragmentRegionTo ?clto.
  ?sentence <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> syntit:Sentence;
     ecrm:P148i_is_component_of ?canto;
    syntit:hasSyntacticalComponent ?cl.
  ?cantica ecrm:P102_has_title ?t_cantica ;
          olires:hasStructuralComponent ?canto .
  ?canto ecrm:P102_has_title ?t_canto ;
  	olires:hasNumber ?num .
  
} LIMIT 10000

`

//colori per frasi sintattiche



var colorssp = d3.scaleQuantize()
	.domain([0, 17])
	.range(["#1f78b4", "#a6cee3", "#b2df8a", "#33a02c", "#fb9a99", "#e31a1c", "#fdbf6f", "#ff7f00",
		"#cab2d6", "#6a3d9a", "#ffff99", "#b15928", "#F46D43",
		"#D53E4F", "#9E0142", "#e377c2", "#7f7f7f", "#bcbd22"]);
/*.range(["#3288bd", "#66c2a5", "#e41a1c", "#4daf4a", "#984ea3", "#d53e4f", "#f46d43", "#ABDDA4",
	"#E6F598", "#FFFFBF", "#FEE08B", "#FDAE61", "#F46D43",
	"#D53E4F", "#9E0142", "#e377c2", "#7f7f7f", "#bcbd22"]);*/

const mapsynttypestopalette = {
	"Ma": 0, "SubI": 1, "SubII": 3, "SubIII": 4, "Co": 5, "Co0": 2,
	"CoI": 9, "CoII": 10, "SubIV": 5, "SubV": 6, "ParentethicalClause": 17,
	"CoIII": 11, "ParentheticalCo": 14, "PseudoCo": 16, "SubVI": 7, "CoIV": 12,
	"CoV": 13, "ParentheticalCoI": 15, "SubVII": 8
}

const maptypes = {
	"Ma": "Principale", "SubI": "Subordinata I grado", "SubII": "Subordinata II grado", "SubIII": "Subordinata III grado", "Co": "Coordinata",
	"CoI": "Coordinata I grado", "CoII": "Coordinata II grado", "SubIV": "Subordinata IV grado", "SubV": "Subordinata V grado",
	"ParentethicalClause": "Parentetica", "CoIII": "Coordinata III grado", "ParentheticalCo": "Coordinata alla parentetica",
	"PseudoCo": "Pseudo-coordinata", "SubVI": "Subordinata VI grado", "CoIV": "Coordinata IV grado", "CoV": "Coordinata V grado",
	"ParentheticalCoI": "Coordinata alla parentetica I grado", "SubVII": "Subordinata VII grado"
}



var orlprefix = 'https://dantenetwork.it/ontology/orl/current/'

var syntitprefix = 'https://dantenetwork.it/ontology/syntit/current/'


function getFraseContext(fraseids, numversi = 3) {
	var context = []
	var listaforme = formeprima;
	var fraseid = fraseids[0]

	var mainid = fraseid.split('-')[0]
	var cantica = mainid.split('_')[0]
	var offset = parseInt(fraseid.split('-')[2]);
	if (cantica == '2') {
		offset = parseInt(fraseid.split('-')[2]) - 33374
		listaforme = formeseconda;
		console.log(listaforme.length)
	}

	if (cantica == '3') {
		offset = parseInt(fraseid.split('-')[2]) - 66588
		listaforme = formeterza;
	}
	maxpos = listaforme.length - 1
	var pos = 0
	var startindex = Math.max(0, (offset - 20))

	for (i = startindex; i < listaforme.length; i++) {
		var tmpos = listaforme[i].split('_')[2]
		if (parseInt(tmpos) == parseInt(fraseid.split('-')[2])) {
			pos = i;
			break;
		}
	}
	var pos2 = pos

	if (fraseids.length > 1)
		lastfraseid = fraseids[fraseids.length - 1]
	else
		lastfraseid = fraseids[0]
	
	for (j = pos; j < listaforme.length; j++) {
		
		var tmpos2 = listaforme[j].split('_')[2]
		if (parseInt(tmpos2) == parseInt(lastfraseid.split('-')[3])) {
			pos2 = j;
			break;
		}
	}


	var minpos = 0;
	var limitv = Math.max((numversi), 3)
	var item = listaforme[pos].split('_');
	var numverso = item[3]
	var spannum = (4 * limitv)

	var contextinf = Math.max(minpos, parseInt(pos) - spannum)
	var contextsup = Math.min(maxpos, parseInt(pos2) + spannum)

	/*var contextinf = parseInt(fraseid.split('-')[2])
	var contextsup = parseInt(fraseid.split('-')[3])*/
	for (j = contextinf; j < contextsup + 1; j++) {
		var tmpform = listaforme[j].split('_');
		if ((tmpform[3] > parseInt(numverso) - limitv) && (tmpform[3] < parseInt(numverso) + limitv)) {
			var contextitem = {}
			contextitem['testo'] = tmpform[0];
			contextitem['verso'] = tmpform[3];
			contextitem['canto'] = tmpform[1];
			contextitem['cantica'] = cantica - 1;
			contextitem['posizione'] = tmpform[2];
			contextitem['catg'] = tmpform[4];
			contextitem['periodo'] = cantica + '_' + tmpform[1] + '_s_' + tmpform[5];
			contextitem['funzperiodo'] = tmpform[6];
			context.push(contextitem);
		}

	}
	return context;
}

function getContextLastPosition(formaid, numversi = 3){
	
	var listaforme = formeprima;
	
	var limitv = Math.max((numversi), 3)
	var maxpos = 0;
	var offset = parseInt(formaid);
	
	if (parseInt(formaid) > 33373 && parseInt(formaid) < 66588) {
			listaforme = formeseconda;
			cantica = 1;
			offset = parseInt(formaid) - 33374

		}
	if (parseInt(formaid) > 66587 && parseInt(formaid) < 99314) {
			listaforme = formeterza;
			cantica = 2;
			offset = parseInt(formaid) - 66588

	}
	maxpos = listaforme.length - 1
	var pos = 0
	var startindex = Math.max(0, (offset - 25))

	//console.log('Forma id: '+formaid+' startindex '+ startindex+' offset '+offset+' ('+cantica+')')
	for (i = startindex; i < listaforme.length; i++) {
		var tmpos = listaforme[i].split('_')[2]
		if (tmpos == formaid) {
			pos = i;
			break;
		}
	}

	var spannum = (11 * limitv)

	var contextsup = Math.min(maxpos, parseInt(pos) + spannum)
	var tmpform = listaforme[contextsup].split('_');
	return(parseInt(tmpform[2]))
	
	
}
function getFormaContext(formaid, numversi = 3) {
	var context = []
	var cantica = 0;
	var listaforme = formeprima;
	var minpos = 0;
	var limitv = Math.max((numversi), 3)
	var maxpos = 0;
	var offset = parseInt(formaid);


	/*if (parseInt(formaid) < 33373) {
		offset = parseInt(formaid)
	}*/

	if (parseInt(formaid) > 33373 && parseInt(formaid) < 66588) {
		listaforme = formeseconda;
		cantica = 1;
		offset = parseInt(formaid) - 33374

	}
	if (parseInt(formaid) > 66587 && parseInt(formaid) < 99314) {
		listaforme = formeterza;
		cantica = 2;
		offset = parseInt(formaid) - 66588

	}
	if (parseInt(formaid) > 99314 || parseInt(formaid) < 0) {
		return [];
	}



	maxpos = listaforme.length - 1
	var pos = 0
	var startindex = Math.max(0, (offset - 25))

	//console.log('Forma id: '+formaid+' startindex '+ startindex+' offset '+offset+' ('+cantica+')')
	for (i = startindex; i < listaforme.length; i++) {
		var tmpos = listaforme[i].split('_')[2]
		if (tmpos == formaid) {
			pos = i;
			//console.log(' in pos: '+pos)
			break;
		}
	}

	
	var item = listaforme[pos].split('_');
	var numverso = item[3]
	var spannum = (11 * limitv)

	var contextinf = Math.max(minpos, parseInt(pos) - spannum)
	var contextsup = Math.min(maxpos, parseInt(pos) + spannum)
	for (j = contextinf; j < contextsup + 1; j++) {
		var tmpform = listaforme[j].split('_');
		if ((tmpform[3] > parseInt(numverso) - limitv) && (tmpform[3] < parseInt(numverso) + limitv)) {
			var contextitem = {}
			contextitem['testo'] = tmpform[0];
			contextitem['verso'] = tmpform[3];
			contextitem['canto'] = tmpform[1];
			contextitem['cantica'] = cantica;
			contextitem['posizione'] = tmpform[2];
			contextitem['catg'] = tmpform[4];
			contextitem['periodo'] = (parseInt(cantica)+1) + '_' + tmpform[1] + '_s_' + tmpform[5];
			contextitem['funzperiodo'] = tmpform[6];
			context.push(contextitem);
		}
	}
	return context;

}

// the basic initial query is parsed

function gimmespq() {
	var SparqlParser = sparqljs.Parser;
	var parser = new SparqlParser();
	return parser.parse(ontoSparqlQuery);


}

// the query is transformed according the form values

function gimmespqfromjson(form) {
	const sparqlgen = sparqljs.Generator;
	const generator = new sparqlgen({ orl: "http://www.w3.org/2000/01/rdf-schema#" })
	const parsedquery = gimmespq()
	if (form.categoria.value != 'all')
		parsedquery.where[0].triples.push(JSON.parse(data21)[form.categoria.value]);
	if (form.query.value != "")
		switch (form.tipo.value) {
			case 'parola':
				parsedquery.where[1].expression.args[1].value = "^" + form.query.value + "$";
				break;
			case 'sottostringa':
				parsedquery.where[1].expression.args[1].value = form.query.value;
				break;
			case 'prefisso':
				parsedquery.where[1].expression.args[1].value = form.query.value;
				break;
			case 'suffisso':
				parsedquery.where[1].expression.args[1].value = form.query.value + "$";
				break;
			default:
				parsedquery.where[1].expression.args[1].value = "^" + form.query.value + "$";
		};
	return generator.stringify(parsedquery);

}

function getStatements() {

	return data21

}


var theguiQ = ''
var multipleCondSpQuery = ''
var bindConcatStatement = ''
var occBindConcatStatement = ''
var posBindConcatStatement = ''

var conditions = []
var filters = []
var unionop = `{"union": {"type": "union", "patterns":[]}, "bgp": {"type": "bgp", "triples":[]}, "group": {"type": "group", "patterns":[]}}`



function parseJsonClause(op, tokens, nowhere) {
	//alert(op)
	var idp = -1
	if (nowhere[0].type == 'filter' && nowhere[0].expression.args[0].value == 'Rappresentazione') {
		//nowhere.splice(0, 1)
		nowhere.splice(0, 2)
	}
	if (op.trim() == 'OR') {

		//nowhere.splice(1, 0, JSON.parse(unionop)['union'])
		nowhere.splice(0, 0, JSON.parse(unionop)['union'])
		//idp = 1
		idp = 0
	}
	if (op.trim() == 'AND') {

		//nowhere.splice(1, 0, JSON.parse(unionop)['group'])
		nowhere.splice(0, 0, JSON.parse(unionop)['group'])
		//idp = 1
		idp = 0

	}
	for (var mtoken in tokens) {
		te_op = tokens[mtoken]
		if ('TERM' in te_op) {
			cond = theguiQ[te_op['TERM']]

			multipleCondSpQuery = buildStatementClause(cond, multipleCondSpQuery, -1, nowhere[idp].patterns, mtoken)

		}
		else
			parseJsonClause(Object.keys(te_op)[0], te_op[Object.keys(te_op)[0]], nowhere.at(-1).patterns)

	}

}


//MULTIPLE CONDITIONS
function buildSPQuery(guiquery) {
	theguiQ = '';
	theguiQ = guiquery;
	var SparqlParser = sparqljs.Parser;
	var spqparser = new SparqlParser();
	if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase') {//Multiple Conditions UR=Periodo
		multipleCondSpQuery = spqparser.parse(sentencetargetquery);
		bindConcatStatement = JSON.parse(sentencetarget_functionbind);
		occBindConcatStatement = JSON.parse(sentencetarget_occbind);
		posBindConcatStatement = JSON.parse(sentencetarget_posbind);

	}
	else
		multipleCondSpQuery = spqparser.parse(ontoSparqlQueryMultCond);
	var parser = peg.generate(hdnquerygrammar);
	var test = guiquery['EsprLogica'].join(" ");
	test = test.replaceAll("( ", "(")
	test = test.replaceAll(" )", ")")
	clauses = parser.parse(test);
	jsonclauses = JSON.parse(clauses)

	for (const ck of Object.keys(jsonclauses)) {
		parseJsonClause(ck, jsonclauses[ck], multipleCondSpQuery.where)

	}
	if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase') {
		multipleCondSpQuery.where.push(bindConcatStatement)
		multipleCondSpQuery.where.push(occBindConcatStatement)

		if (posBindConcatStatement['expression']['args'].length) {
			multipleCondSpQuery.where.push(posBindConcatStatement)
			multipleCondSpQuery.variables.push(JSON.parse(sentencetarget_posVariable))
			//multipleCondSpQuery.where.push(sentencetargetstatement_posCoalesce)
		}

	}

}

//BUILD THE QUERY!

function buildSQ(stquery) {

	var filtroContesto;
	stringInSparql = false;
	var SparqlParser = sparqljs.Parser;
	var parser = new SparqlParser();
	//Prendo la query SPARQL template
	var parsedquery = parser.parse(ontoSparqlQuery);
	console.log(stquery)

	if (stquery['QueryAvanzata'] == 1 && stquery['EsprLogica'] != null && stquery['EsprLogica'].length > 1) {
		//parsedquery = parser.parse(ontoSparqlQueryMultCond)
		buildSPQuery(stquery)
		return multipleCondSpQuery;
	}

	if (stquery['QueryAvanzata'] == 1 && stquery['EsprLogica'] != null && stquery['EsprLogica'] != '' && stquery['EsprLogica'].length == 1) {
		clause = stquery['EsprLogica']

		filtroContesto = getFiltroContestoJson(JSON.parse(stquery[clause[0]]['contesto']))
		
		
		//if (stquery[clause]['TipoClausola'] == 'Sintattico') {
		if (stquery[clause]['typeSyntax0'].trim()!='' && stquery[clause]['typeSyntax0'].trim()!='.+'){
			parsedquery = parser.parse(ontoSparqlQuerySynt);
			var tempsyntquery = buildSintacticClause(stquery[clause], parsedquery, 2)
			if (filtroContesto.length > 0) {
				for (tmpc of filtroContesto) {
					tempsyntquery.where.splice(0, 0, tmpc)
				}
			}
			return tempsyntquery
		}

		myquery = buildClause(stquery[clause], parsedquery, 2)
		if (filtroContesto.length > 0) {
			for (tmpc of filtroContesto) {
				console.log(filtroContesto[0])
				myquery.where.splice(1, 0, tmpc)
			}

			if (stquery[clause]['queryText'].trim() == "") {
				if (myquery.where[0].type == 'filter')
					myquery.where.splice(0, 1)
			}

		}
		return (myquery)
	}
	//Simple query

	filtroContestoJson = getFiltroContestoJson(JSON.parse(stquery['Clausola0']['contesto']))
	if (filtroContestoJson.length > 0) {
		for (tmpc of filtroContestoJson) {
			//console.log(filtroContesto[0])
			parsedquery.where.splice(1, 0, tmpc)
		}


	}

	if (stquery['Clausola0']['queryText'] != "" && stquery['Clausola0']['Attiva'] == 1) {
		searchtext = stquery['Clausola0']['queryText']
		let strval = searchtext

		if (stquery['Clausola0']['opzioni_testo'] == 'parola') {
			strval = "^" + searchtext.trim() + "$";
		}
		if (stquery['Clausola0']['opzioni_testo'] == 'sottostringa') {
			strval = searchtext.trim();
		}
		if (stquery['Clausola0']['opzioni_testo'] == 'suffisso') {
			strval = searchtext.trim() + "$";
		}
		if (stquery['Clausola0']['opzioni_testo'] == 'prefisso') {
			strval = "^" + searchtext.trim();
		}




		parsedquery.where[0].expression.args[1].value = strval;
		if (stquery['Clausola0']['lemma_forma'] == 'lemma') {
			parsedquery.where[0].expression.args[0].value = "lm";
			parsedquery.where.splice(1, 1)
			parsedquery.where[1].patterns[0].triples.splice(0, 1)
		}

	}
	else {
		console.log('Simple query, no param')
		parsedquery.where.splice(0, 1)
	}

	return (parsedquery)

}



//Filtro Contesto


function getFiltroContestoJson(datiContesto) {
	var cantica = 0;
	var canticheids = new Set()
	for (contestoCantica of datiContesto) {
		var contextids = []
		cantica++;
		for (const [index, element] of contestoCantica.entries()) {
			if (element == 1) {
				//console.log('Cantica ' + cantica + ', Canto ' + (parseInt(index) + 1));
				contextids.push(parseInt(index) + 1)
			}
		}
		if (contextids.length > 0) {
			canticheids[cantica] = contextids
		}
	}

	if (Object.keys(canticheids).length > 0) {

		//console.log(JSON.stringify(canticheids))
		var test = buildFilterContextJson(canticheids)

		return (test)
	}
	else
		return []
}

function buildStatementClause(clause, parsedquery, whereind, theplace, token) {
	//
	var tmpgroup = ''
	if (clause['TipoClausola'] == "Sintattico") {
		if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase')
			tmpgroup = JSON.parse(sentencetarget_syntgroup)
		else
			tmpgroup = JSON.parse(syntgroup)
	}
	if (clause['TipoClausola'] == "Grammaticale") {
		if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase') {
			tmpgroup = JSON.parse(sentencetarget_morphgroup_short)
		}

		else
			tmpgroup = JSON.parse(morphgroup)
	}


	if (clause['queryText'] != null && clause['queryText'].trim() != "") {


		var stmt = buildFilterStatement(clause['lemma_forma'], clause['queryText'].trim(), clause['opzioni_testo'])
		tmpgroup.patterns.unshift(stmt)
		//tmpgroup.patterns.push(JSON.parse(unionop)['bgp']);
		tmpgroup.patterns.splice(1, 0, JSON.parse(unionop)['bgp']);
		if (clause['lemma_forma'] == 'lemma') {
			tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_lexicalform))
			tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_canonicalform))
			tmpgroup.patterns.at(-1).triples.push(JSON.parse(lemma_writtenrepresentation))
		}
		else {
			tmpgroup.patterns[1].triples.push(JSON.parse(writtenrepresentation))
			//tmpgroup.patterns.at(-1).triples.push(JSON.parse(writtenrepresentation))
		}

	}

	if (clause['typeGramm0'] != null && clause['typeGramm0'] != "all")
		if (whereind > -1)
			parsedquery.where[whereind].triples.push(JSON.parse(data21)[clause['typeGramm0']]);
		else {
			tmpgroup.patterns.push(JSON.parse(unionop)['bgp']);
			tmpgroup.patterns.at(-1).triples.push(JSON.parse(data21)[clause['typeGramm0']]);

		}

	if (clause['typeGramm0'] != null && Object.keys(sottoCategorie).includes(clause['typeGramm0'].trim())) {

		sctmp = sottoCategorie[clause['typeGramm0'].trim()]
		sctk = Object.keys(sctmp)
		for (ke in sctk) {

			keval = clause[sctk[ke]]
			if (keval != null && keval != '') {
				sttmts = sctmp[sctk[ke]]
				if (sttmts[keval] != null && (sttmts[keval].split(':')[1]) != null) {
					subcatstat = buildsubcategoryClause(sttmts[keval])
					if (whereind > -1)
						parsedquery.where[whereind].triples.push(subcatstat);
					else
						//theplace.at(-1).triples.push(subcatstat);
						tmpgroup.patterns.at(-1).triples.push(subcatstat);
				}
			}
		}
	}

	if (clause['TipoClausola'] == 'Grammaticale') {
		if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase') {
			var tmpg = JSON.stringify(tmpgroup)
			tmpg = tmpg.replaceAll('"Rappresentazione"', '"Rappresentazione' + token + '"')
			tmpg = tmpg.replaceAll('"form"', '"form' + token + '"')
			tmpg = tmpg.replaceAll('"lent"', '"lent' + token + '"')
			tmpg = tmpg.replaceAll('"cf"', '"cf' + token + '"')
			tmpg = tmpg.replaceAll('"fa"', '"fa' + token + '"')
			tmpg = tmpg.replaceAll('"pos"', '"pos' + token + '"')
			tmpg = tmpg.replaceAll('"lm"', '"lm' + token + '"')
			tmpg = tmpg.replaceAll('"reg"', '"reg' + token + '"')
			tmpg = tmpg.replaceAll('"clg"', '"clg' + token + '"')
			tmpg = tmpg.replaceAll('"cloccte"', '"cloccte' + token + '"')
			tmpgroup = JSON.parse(tmpg)
			var tmppos = `{
                    "type": "operation",
                    "operator": "str",
                    "args": [
                        {
                            "termType": "Variable",
                            "value": "pos`+ token + `"
                        }
                    ]
                }
                `
			posBindConcatStatement['expression']['args'].push(JSON.parse(tmppos))
			tmppos = `{
                    "termType": "Literal",
                    "value": ";",
                    "language": "",
                    "datatype": {
                        "termType": "NamedNode",
                        "value": "http://www.w3.org/2001/XMLSchema#string"
                    }
                }`
			posBindConcatStatement['expression']['args'].push(JSON.parse(tmppos))
		}
	}

	// CLAUSOLA SINTATTICA

	if (clause['TipoClausola'] == "Sintattico") {
		tmpgroup.patterns.push(JSON.parse(unionop)['bgp']);

		//controllo se tra i filtri c'e una stringa
		if (clause['queryText'] != null && clause['queryText'].trim() != "") {
			//aggiungo statements per legare la stringa alla clausola

			tmpgroup.patterns[1].triples.push(JSON.parse(occurrenceof_form))
			tmpgroup.patterns[1].triples.push(JSON.parse(clauseocc_hascomponent_formocc))
			tmpgroup.patterns[1].triples.push(JSON.parse(occurrenceof_clause))
		}
		var functS = clause['functionSyntax'];
		var typeS = clause['typeSyntax0']
		console.log(functS + ' ' + typeS)
		var myf = ''
		if (functS != null && functS != ".+") {
			myf = buildsyntClause(funzione_clausola[functS])
			if (myf != '')
				tmpgroup.patterns.at(-1).triples.push(myf)
		}
		if (typeS != null && typeS != ".+") {
			var alltipi = Object.assign(macrotipi_sint, tipi_sint);
			let mymt = alltipi[typeS]

			if (listaMacroTipiConSubTipo.includes(mymt.split(':')[1])) {
				let myfa = buildMacroSyntType(mymt)
				for (fa in myfa) {
					//tmpgroup.patterns.at(-1).triples.push(myfa[fa])
					tmpgroup.patterns.push(myfa[fa])
				}
			}
			else {
				var tmptr = alltipi[typeS].split(';')
				for (indttr in tmptr) {
					myf = buildsyntClause(tmptr[indttr])
					if (myf != '')
						tmpgroup.patterns.at(-1).triples.push(myf)
				}

			}

		}
		if (theguiQ['unitaRicerca'] == 'periodo' || theguiQ['unitaRicerca'] == 'frase') {
			mytest = JSON.stringify(tmpgroup)
			mytest = mytest.replaceAll(':"cl"', ':"cl' + token + '"')
			mytest = mytest.replaceAll(':"clatype"', ':"clatype' + token + '"')
			mytest = mytest.replaceAll(':"clafunction"', ':"clafunction' + token + '"')
			mytest = mytest.replaceAll(':"cloccu"', ':"cloccu' + token + '"')
			mytest = mytest.replaceAll(':"fa"', ':"fa' + token + '"')
			mytest = mytest.replaceAll(':"form"', ':"form' + token + '"')
			mytest = mytest.replaceAll(':"Rappresentazione"', ':"Rappresentazione' + token + '"')
			var mystrb = `{
                    "type": "operation",
                    "operator": "str",
                    "args": [
                        {
                            "termType": "Variable",
                            "value": "clafunction`+ token + `"
                        }
                    ]
                }
                `
			bindConcatStatement['expression']['args'].push(JSON.parse(mystrb))
			mystrb = `{
                    "type": "operation",
                    "operator": "str",
                    "args": [
                        {
                            "termType": "Variable",
                            "value": "cl`+ token + `"
                        }
                    ]
                }
                `
			occBindConcatStatement['expression']['args'].push(JSON.parse(mystrb))
			mystrb = `{
                    "termType": "Literal",
                    "value": ";",
                    "language": "",
                    "datatype": {
                        "termType": "NamedNode",
                        "value": "http://www.w3.org/2001/XMLSchema#string"
                    }
                }`
			bindConcatStatement['expression']['args'].push(JSON.parse(mystrb))
			occBindConcatStatement['expression']['args'].push(JSON.parse(mystrb))
			tmpgroup = JSON.parse(mytest)


		}
	}

	theplace.push(tmpgroup)

	return parsedquery

}



function buildSintacticClause(clause, parsedquery, whereind) {

	if (clause['queryText'].trim() != "") {

		var strval = getStringFilter(clause['queryText'].trim(), clause['opzioni_testo'])
		parsedquery.where[0].expression.args[1].value = strval;
		if (clause['lemma_forma'] == 'lemma')
			parsedquery.where[0].expression.args[0].value = "lm";
	}
	else {
		if (parsedquery.where[0].type == 'filter' && parsedquery.where[0].expression.args[0].value == 'Rappresentazione')
			//remove the filter for text CHANGE!
			parsedquery.where.splice(0, 1)
		parsedquery.where.splice(0, 1)
		parsedquery.where[0].triples.splice(5, 1)
		parsedquery.where[0].triples.splice(4, 1)
		parsedquery.where[0].triples.splice(3, 1)
		parsedquery.where[0].triples.splice(2, 1)
		parsedquery.where[0].triples.splice(1, 1)
		parsedquery.where[0].triples.splice(0, 1)
		whereind = whereind - 1
	}


	var functS = clause['functionSyntax'];
	var typeS = clause['typeSyntax0']
	console.log(functS + ' ' + typeS)
	if (functS != null && functS != ".+") {
		//console.log('functS '+funzione_clausola['princ'])
		var myf = buildsyntClause(funzione_clausola[functS])

		if (myf == '')
			return parsedquery
		parsedquery.where.at(-1).triples.push(myf);
	}
	if (typeS != null && typeS != ".+") {
		var alltipi = Object.assign(macrotipi_sint, tipi_sint);
		let mymt = alltipi[typeS]
		if (listaMacroTipiConSubTipo.includes(mymt.split(':')[1])) {
			let myfa = buildMacroSyntType(mymt)
			for (fa in myfa) {
				//parsedquery.where.at(-1).triples.push(myfa[fa])
				parsedquery.where.push(myfa[fa])
			}
		}
		else {

			var tmptr = macrotipi_sint[typeS].split(';')
			for (indttr in tmptr) {
				myf = buildsyntClause(tmptr[indttr])
				if (myf != '')
					parsedquery.where.at(-1).triples.push(myf)
			}
		}


	}
	return parsedquery
}

function buildClause(clause, parsedquery, whereind) {

	if (clause['TipoClausola'] == 'Sintattico')
		return buildSintacticClause(clause, parsedquery, whereind)



	if (clause['typeGramm0'] != null && clause['typeGramm0'] != "all")
		if (whereind > -1)
			//parsedquery.where[whereind].triples.push(JSON.parse(data21)[clause['typeGramm0']]);
			parsedquery.where[2].patterns[0].triples.splice(0, 0, JSON.parse(data21)[clause['typeGramm0']]);
		else {
			parsedquery.where.at(-1).patterns.push(JSON.parse(unionop)['bgp']);
			parsedquery.where.at(-1).patterns.at(-1).triples.push(JSON.parse(data21)[clause['typeGramm0']]);
		}


	if (clause['typeGramm0'] != null && Object.keys(sottoCategorie).includes(clause['typeGramm0'].trim())) {
		//sctmp=JSON.parse(sottoCategorieSostantivi)
		sctmp = sottoCategorie[clause['typeGramm0'].trim()]
		sctk = Object.keys(sctmp)
		for (ke of sctk) {

			keval = clause[ke]
			if (keval != null && keval != '') {
				sttmts = sctmp[ke]
				if (sttmts[keval] != null && (sttmts[keval].split(':')[1]) != null) {
					subcatstat = buildsubcategoryClause(sttmts[keval])
					if (whereind > -1)
						parsedquery.where[2].patterns[0].triples.push(subcatstat);
					else
						parsedquery.where.at(-1).patterns.at(-1).triples.push(subcatstat);
				}
			}
		}
	}

	if (clause['queryText'].trim() != "") {

		var strval = getStringFilter(clause['queryText'].trim(), clause['opzioni_testo'])
		parsedquery.where[0].expression.args[1].value = strval;
		if (clause['lemma_forma'] == 'lemma')
			parsedquery.where[0].expression.args[0].value = "lm";
	}
	else {
		if (parsedquery.where[0].type == 'filter' && parsedquery.where[0].expression.args[0].value == 'Rappresentazione')
			parsedquery.where.splice(0, 1)
		whereind = whereind - 1
	}

	return parsedquery

}

function getStringFilter(filter, opzione) {
	var strval = "^" + filter.trim() + "$";
	if (opzione != "")
		switch (opzione) {
			case 'parola':
				strval = "^" + filter.trim() + "$";
				break;
			case 'sottostringa':
				strval = filter.trim();
				break;
			case 'prefisso':
				strval = "^" + filter.trim();
				break;
			case 'suffisso':
				strval = filter.trim() + "$";
				break;
			default:
				strval = "^" + filter.trim() + "$";

		};
	return (strval)
}
//costruzione filtri per query

//filtri contesto
function buildFilterContextJson(contextcantiche) {
	var resfilters = []

	var contextgroup = ` {
        		"type": "group",
        		"patterns": [
            				{
                			"type": "bgp",
                			"triples": [
                    					{"subject": {"termType": "Variable","value": "cantica"},
                        				"predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P102_has_title"},
                        				"object": {"termType": "Variable","value": "t_cantica"}},
                        			    {"subject": {"termType": "Variable","value": "cantica"},
                                        "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/hasStructuralComponent"},
                                        "object": {"termType": "Variable","value": "canto"}},
                                       {"subject": {"termType": "Variable","value": "canto"},
                                        "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/hasNumber"},
                                        "object": {"termType": "Variable","value": "num"}}
                    				   
                                 ]
                      }
                      ]
      }

`

	var filtercontexttemplate = `{
    	"type": "filter",
    	"expression": {
        	"type": "operation",
        	"operator": "in",
        	"args": [
            	{
                	"termType": "Variable",
                	"value": "num"
            	}
        	]
   	 	}
	}`

	var filtercontextcantichetemplate = `{
    	"type": "filter",
    	"expression": {
        	"type": "operation",
        	"operator": "in",
        	"args": [
            	{
                	"termType": "Variable",
                	"value": "t_cantica"
            	}
        	]
   	 	}
	}`

	var itemcontexttemplate = `
                {
                    "termType": "Literal",
                    "value": "na",
                    "language": "",
                    "datatype": {
                        "termType": "NamedNode",
                        "value": "http://www.w3.org/2001/XMLSchema#short"
                    }
                }`
	var canticacontexttemplate = `
                {
                    "termType": "Literal",
                    "value": "na",
                    "language": "",
                    "datatype": {
                        "termType": "NamedNode",
                        "value": "http://www.w3.org/2001/XMLSchema#string"
                    }
                }`


	var canticheliteral = ['Inferno', 'Purgatorio', 'Paradiso']

	for (var ky in contextcantiche) {
		var contextfilter = []
		var cantichecontextfilter = []
		var cgroup = JSON.parse(contextgroup)
		if (contextcantiche.hasOwnProperty(ky)) {
			///console.log(`test ${ky} : ${contextcantiche[ky]}`)

			var cfilter = JSON.parse(canticacontexttemplate);

			cfilter['value'] = canticheliteral[ky - 1]
			cantichecontextfilter.push(cfilter)
			for (var kval in contextcantiche[ky]) {
				//console.log(contextcantiche[ky][kval])
				var myfilter = JSON.parse(itemcontexttemplate);
				myfilter['value'] = contextcantiche[ky][kval].toString()
				contextfilter.push(myfilter)
			}
		}
		if (contextfilter.length > 0) {
			var filters = JSON.parse(filtercontexttemplate)
			var cantichefilters = JSON.parse(filtercontextcantichetemplate)
			filters['expression']['args'].push(contextfilter)

			//resfilters.push(filters)
			cgroup.patterns.splice(0, 0, filters)
			cantichefilters['expression']['args'].push(cantichecontextfilter)

			cgroup.patterns.splice(0, 0, cantichefilters)
			resfilters.push(cgroup)
		}

	}
	var uniontmp = `{"type": "union", "patterns":[]}`
	var tmpres = []
	jsunion = JSON.parse(uniontmp)
	if (resfilters.length > 1) {

		for (filter in resfilters) {
			jsunion.patterns.push(resfilters[filter])
		}
		tmpres.push(jsunion)
		return (tmpres)
	}
	if (resfilters.length > 0) {

		tmpres.push(resfilters[0].patterns[1])
		tmpres.push(resfilters[0].patterns[0])
	}
	return (tmpres)

}


function buildFilterStatement(target, filter, opzione) {

	var filtertemplate = `{
    "type": "filter",
    "expression": {
        "type": "operation",
        "operator": "regex",
        "args": [
            {
                "termType": "Variable",
                "value": "Rappresentazione"
            },
            {
                "termType": "Literal",
                "value": "^andare$",
                "language": "",
                "datatype": {
                    "termType": "NamedNode",
                    "value": "http://www.w3.org/2001/XMLSchema#string"
                }
            },
            {
                "termType": "Literal",
                "value": "i",
                "language": "",
                "datatype": {
                    "termType": "NamedNode",
                    "value": "http://www.w3.org/2001/XMLSchema#string"
                }
            }
        ]
    }
}`


	var statement = JSON.parse(filtertemplate)
	/*
	if (filter.trim().slice(-1) !== '*')
		strval = "^" + filter.trim() + "$";
	else
		strval = filter.trim().slice(0, -1)
		*/
	var strval = getStringFilter(filter, opzione);

	statement.expression.args[1].value = strval;
	if (target == 'lemma')
		statement.expression.args[0].value = "lm";

	return (statement)
}


//"hasClauseType:Comparativa"
//           
//?cl syntit:hasClauseType ?tipoSint .
//?tipoSint rdf:type syntit:ClauseSubType ;
// ecrm:P127_has_broader_term syntit:Comparativa .

function buildMacroSyntType(sttmnt) {
	var uniontmpms = `{"type": "union", "patterns":[]}`
	var trm1 = `{
			"type": "bgp",
			"triples": 
			 [
				{"subject": {"termType": "Variable","value": "cl"},
			   "predicate": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"},
		       "object": {"termType": "Variable","value": "tipoSint"}},
                {"subject": {"termType": "Variable","value": "tipoSint"},
			   "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"},
			   "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/ClauseSubType"}},
                {"subject": {"termType": "Variable","value": "tipoSint"},
			   "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P127_has_broader_term"},
		       "object": {"termType": "NamedNode"}}
                    				   
              ]
              }`
	var tmplate = `{"subject": {"termType": "Variable", "value":"cl"}, 
		"predicate": {"termType":"NamedNode"}, 
		"object": {"termType": "NamedNode"}}`

	var t1m = `{"subject": {"termType": "Variable","value": "cl"},
			   "predicate": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"},
		       "object": {"termType": "Variable","value": "tipoSint"}}`
	var t2m = `{"subject": {"termType": "Variable","value": "tipoSint"},
			   "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"},
			   "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/syntit/current/ClauseSubType"}}`
	var t3m = `{"subject": {"termType": "Variable","value": "tipoSint"},
			   "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P127_has_broader_term"},
		       "object": {"termType": "NamedNode"}}`
	var res = []



	var obj = syntitprefix + (sttmnt.split(':')[1])

	var predicate = syntitprefix + (sttmnt.split(':')[0])

	var statement = JSON.parse(tmplate)

	statement['predicate']['value'] = predicate
	statement['object']['value'] = obj

	var grstmt = JSON.parse(trm1)
	grstmt['triples'][2]['object']['value'] = obj

	var unionst = JSON.parse(uniontmpms)
	unionst['patterns'].push(grstmt)
	unionst['patterns'].push(statement)
	res.push(unionst)
	//var statement = JSON.parse(t3m)
	//statement['object']['value'] = obj
	//res.push(JSON.parse(t1m))
	//res.push(JSON.parse(t2m))
	//res.push(statement)
	return res
}

function buildsyntClause(sttmnt) {


	var tmplate = `{"subject": {"termType": "Variable", "value":"cl"}, 
		"predicate": {"termType":"NamedNode"}, 
		"object": {"termType": "NamedNode"}}
	`


	console.log(sttmnt)

	var predicate = syntitprefix + (sttmnt.split(':')[0])
	var obj = syntitprefix + (sttmnt.split(':')[1])
	var statement = JSON.parse(tmplate)

	statement['predicate']['value'] = predicate
	statement['object']['value'] = obj

	return (statement)

}

function buildsubcategoryClause(sttmnt) {

	subcattmplate = `{"subject": {"termType": "Variable", "value":"form"}, 
	"predicate": {"termType":"NamedNode"}, 
	"object": {"termType": "NamedNode"}}
	`

	predicate = orlprefix + (sttmnt.split(':')[0])
	obj = orlprefix + (sttmnt.split(':')[1])
	subcatstatement = JSON.parse(subcattmplate)

	subcatstatement['predicate']['value'] = predicate
	subcatstatement['object']['value'] = obj

	return (subcatstatement)

}
//GESTIONE CITAZIONI/COMMENTI
//return JSON object
function getVersiConCitazioniJson(canticapar = '', cantopar = '') {
	let citcantiche = ['Inferno', 'Purgatorio', 'Paradiso']
	if (canticapar == '') {
		citazioni.map(function(item) {
			console.log(item['Cantica'] + ', ' + item['Canto'] + ', ' + item['Verso'].split('-')[0]);
		})
		return
	}
	var citazionitemp = {}
	citazioni.map(function(item) {
		if (item['Cantica'] == canticapar && item['Canto'] == cantopar) {

			let tca = item['Canto']
			if (tca.startsWith('0'))
				tca = tca.replace('0', '')
			let citid = (citcantiche.indexOf(item['Cantica']) + 1).toString() + '_' + tca + '_' + item['Verso']//.split('-')[0]
			//console.log(citid)
			var commentsItem = {}
			commentsItem['verso'] = citid;
			commentsItem['annotazione'] = item['Ann'];
			commentsItem['commentario'] = item['Com'];
			commentsItem['frammentoNota'] = item['FrN'];
			commentsItem['AutoreCitazione'] = item['AC'];
			commentsItem['FonteCitazione'] = item['F'];
			commentsItem['LuogoFonteCitazione'] = item['LF'];
			commentsItem['NotaFonteCitazione'] = item['NF'];
			commentsItem['TestoFonteCitazione'] = item['TF'];
			commentsItem['URLFonteCitazione'] = item['UF'];
			commentsItem['NaturaRiferimento'] = item['NaRi'];
			commentsItem['RapportoCommentoCommentatoreText'] = item['RCC'];
			commentsItem['RapportoSoggettoOggetto'] = item['RSO'];
			commentsItem['NomeAutoreCitazione'] = item['Aut'];
			commentsItem['TitoloFonteCitazione'] = item['TiFo'];
			commentsItem['VersoCitazione'] = item['Verso'];

			if (item['AC'] == '') {
				commentsItem['AutoreCitazione'] = 'autore'
			}

			if (item['TiCi'] == 'no') {
				commentsItem['TipoCitazione'] = ''
			}
			else {
				commentsItem['TipoCitazione'] = item['TiCi']
			}
			//'CEP', 'CIM', 'CTE', 'CMO', 'CST', 'CTO'

			if (item['CEP'] == 'no') {
				commentsItem['CitEpisodi'] = ''
			}
			else {
				commentsItem['CitEpisodi'] = item['CEP']
			}

			if (item['CIM'] == 'no') {
				commentsItem['CitImmagini'] = ''
			}
			else {
				commentsItem['CitImmagini'] = item['CIM']
			}

			if (item['CTE'] == 'no') {
				commentsItem['CitTeorie'] = ''
			}
			else {
				commentsItem['CitTeorie'] = item['CTE']
			}

			if (item['CMO'] == 'no') {
				commentsItem['CitMotivi'] = ''
			}
			else {
				commentsItem['CitMotivi'] = item['CMO']
			}

			if (item['CST'] == 'no') {
				commentsItem['CitStilemi'] = ''
			}
			else {
				commentsItem['CitStilemi'] = item['CST']
			}

			if (item['CTO'] == 'no') {
				commentsItem['CitTopografie'] = ''
			}
			else {
				commentsItem['CitTopografie'] = item['CTO']
			}

			if (citazionitemp.hasOwnProperty(citid)) {
				citazionitemp[citid].push(commentsItem)
			}
			else {
				var tmpar = []
				tmpar.push(commentsItem)
				citazionitemp[citid] = tmpar
			}
		}

	})
	console.log(citazionitemp)
	return citazionitemp;
}

//inizializzazione UI per query sulle citazioni
function getAutoriFontiCitazioni() {
	var listaAutori = new Set()
	citazioni.map(function(item) {
			listaAutori.add(item['Aut']);

			if (item['Aut'] == '') {
				listaAutori.add('Sconosciuto')
			}

	})
	
	return Array.from(listaAutori)
}

function getCommentatori() {
	var listaCommentatori = new Set()
	citazioni.map(function(item) {
			listaCommentatori.add(item['Com']);

			if (item['Com'] == '') {
				listaCommentatori.add('Sconosciuto')
			}

	})
	
	return Array.from(listaCommentatori)
}

const myiframe = document.getElementsByClassName("minimap__content");
function resetGraphStruct() {

	var periodograph = document.getElementById("periodograph");
	if (periodograph != null) {
		let showngr = document.getElementById("periodograph").getAttribute('name').split("_")
		var tmpsent = showngr[0] + "_" + showngr[1] + "_s_" + showngr[2]
		periodograph.parentNode.removeChild(periodograph);

		//var sentence = document.getElementsByClassName(lsentid);
		var sentence = document.getElementsByClassName(tmpsent);

		for (let i = 0; i < sentence.length; i++) {
			//var matches = listaClausoleRisultato.filter(s => s.includes(sentence[i].classList[0]));
			sentence[i].classList.remove('font-italic');
			if (!vistaPeriodi && !listaPeriodiRisultato.includes(tmpsent)
				&& listaClausoleRisultato.filter(cl => cl.split('-')[0]==tmpsent).length==0)
				sentence[i].style.removeProperty('color');

			sentence[i].classList.remove('font-weight-normal');

		}

		//reset Minimap
		var iframeDocument = myiframe[0].contentDocument || myiframe[0].contentWindow.document;
		if (!iframeDocument) {
			throw "iframe couldn't be found in DOM.";
		}
		var iframeSentence = iframeDocument.getElementsByClassName(tmpsent);
		for (let i = 0; i < iframeSentence.length; i++) {
			iframeSentence[i].classList.remove('font-italic');
			if (!vistaPeriodi)
				iframeSentence[i].style.removeProperty('color');

			iframeSentence[i].classList.remove('font-weight-normal');
		}
		//EMPTY CARD
		emptyStructCard()

		if (tmpsent == lsentid) {

			return true
		}

		return false

	}
}
//end

var sottoCategorie = {
	"verbovolgare": {
		"Diatesi": { "Attivo": "TipoDiatesiVerboVolgare:VerboVolgareAttivo", "Passivo": "TipoDiatesiVerboVolgare:VerboVolgarePassivo" },
		"Transitivita": { "Intransitivo": "TipoTransitivitàVerboVolgare:VerboVolgareIntransitivo", "Transitivo": "TipoTransitivitàVerboVolgare:VerboVolgareTransitivo" },
		"Genere": { "Femminile": "TipoGenereVerboVolgare:GenereFemminileVerboVolgare", "Maschile": "TipoGenereVerboVolgare:GenereMaschileVerboVolgare" },
		"Numero": { "Singolare": "TipoNumeroVerboVolgare:NumeroSingolareVerboVolgare", "Plurale": "TipoNumeroVerboVolgare:NumeroPluraleVerboVolgare" },
		"Pers": { "Impersonale": "VerboVolgareImpersonale:VerboVolgareImpersonale" },
		"Rifl": { "Riflessivo": "VerboVolgareRiflessivo:VerboVolgareRiflessivo" },
		"Coniugazione": {
			"Prima coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgarePrimaConiugazione", "Seconda coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareSecondaConiugazione",
			"Terza coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareTerzaConiugazione",
			"Essere coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareAusiliareEssere",
			"Avere coniugazione": "TipoConiugazioneVerboVolgare:VerboVolgareAusiliareAvere"
		},
		"Tempi": {
			"Indicativo presente": "TipoTempoVerboVolgare:PresenteIndicativoVerboVolgare", "Indicativo passato prossimo": "TipoTempoVerboVolgare:PassatoProssimoIndicativoVerboVolgare",
			"Indicativo imperfetto": "TipoTempoVerboVolgare:ImperfettoIndicativoVerboVolgare", "Indicativo passato remoto": "TipoTempoVerboVolgare:PassatoRemotoIndicativoVerboVolgare",
			"Indicativo trapassato prossimo": "TipoTempoVerboVolgare:TrapassatoProssimoIndicativoVerboVolgare", "Indicativo trapassato remoto": "TipoTempoVerboVolgare:TrapassatoRemotoIndicativoVerboVolgare",
			"Indicativo futuro semplice": "TipoTempoVerboVolgare:FuturoSempliceIndicativoVerboVolgare", "Indicativo futuro anteriore": "TipoTempoVerboVolgare:FuturoAnterioreIndicativoVerboVolgare",
			"Congiuntivo presente": "TipoTempoVerboVolgare:PresenteCongiuntivoVerboVolgare", "Congiuntivo imperfetto": "TipoTempoVerboVolgare:ImperfettoCongiuntivoVerboVolgare",
			"Congiuntivo passato": "TipoTempoVerboVolgare:PassatoCongiuntivoVerboVolgare", "Congiuntivo trapassato": "TipoTempoVerboVolgare:TrapassatoCongiuntivoVerboVolgare",
			"Condizionale presente": "TipoTempoVerboVolgare:PresenteCondizionaleVerboVolgare", "Condizionale passato": "TipoTempoVerboVolgare:PassatoCondizionaleVerboVolgare",
			"Imperativo presente": "TipoTempoVerboVolgare:PresenteImperativoVerboVolgare", "Infinito presente": "TipoTempoVerboVolgare:PresenteInfinitoVerboVolgare",
			"Infinito passato": "TipoTempoVerboVolgare:PassatoInfinitoVerboVolgare", "Participio presente": "TipoTempoVerboVolgare:PresenteParticipioVerboVolgare",
			"Participio passato": "TipoTempoVerboVolgare:PassatoParticipioVerboVolgare", "Gerundio presente": "TipoTempoVerboVolgare:PresenteGerundioVerboVolgare",
			"Gerundio passato": "TipoTempoVerboVolgare:PassatoGerundioVerboVolgare"
		},
		"Funzione": {
			"Aggettivo": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneAggettivo", "Sostantivo maschile": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneSostantivoMaschile",
			"Sostantivo femminile": "TipoFunzioneVerboVolgare:VerboVolgareFunzioneSostantivoFemminile"
		},
		"Declinazione": {
			"Prima declinazione": "TipoDeclinazioneVerboVolgare:PrimaDeclinazioneVerboVolgare", "Seconda declinazione": "TipoDeclinazioneVerboVolgare:SecondaDeclinazioneVerboVolgare",
			"Terza declinazione": "TipoDeclinazioneVerboVolgare:TerzaDeclinazioneVerboVolgare"
		},
		"Persona": {
			"1ª persona singolare": "TipoPersonaVerboVolgare:PrimaPersonaSingolareVerboVolgare", "2ª persona singolare": "TipoPersonaVerboVolgare:SecondaPersonaSingolareVerboVolgare",
			"3ª persona singolare": "TipoPersonaVerboVolgare:TerzaPersonaSingolareVerboVolgare", "1ª persona plurale": "TipoPersonaVerboVolgare:PrimaPersonaPluraleVerboVolgare",
			"2ª persona plurale": "TipoPersonaVerboVolgare:SecondaPersonaPluraleVerboVolgare", "3ª persona plurale": "TipoPersonaVerboVolgare:TerzaPersonaPluraleVerboVolgare"
		}

	},

	"sostantivovolgare": {
		"Genere_lemma": { "Lemma femminile": "TipoGenereLemmaSostantivoVolgare:GenereFemminileLemmaSostantivoVolgare", "Lemma maschile": "TipoGenereLemmaSostantivoVolgare:GenereMaschileLemmaSostantivoVolgare" },
		"Genere_forma": { "Forma femminile": "TipoGenereSostantivoVolgare:GenereFemminileSostantivoVolgare", "Forma maschile": "TipoGenereSostantivoVolgare:GenereMaschileSostantivoVolgare" },
		"Numero": { "Singolare": "TipoNumeroSostantivoVolgare:NumeroSingolareSostantivoVolgare", "Plurale": "TipoNumeroSostantivoVolgare:NumeroPluraleSostantivoVolgare" },
		"riflpers": { "In locuzione": "SostantivoVolgareInLocuzione:Lv_lv" },
		"Declinazione_sostantivo": {
			"Prima declinazione": "TipoDeclinazioneSostantivoVolgare:PrimaDeclinazioneSostantivoVolgare", "Seconda declinazione": "TipoDeclinazioneSostantivoVolgare:SecondaDeclinazioneSostantivoVolgare",
			"Terza declinazione": "TipoDeclinazioneSostantivoVolgare:TerzaDeclinazioneSostantivoVolgare"
		}
	},

	"pronomevolgare": {
		"Genere": { "Femminile": "generePronomeVolgare:PronomeVolgareFemminile", "Maschile": "generePronomeVolgare:PronomeVolgareMaschile" },
		"Numero": { "Singolare": "TipoNumeroPronomeVolgare:PronomeVolgareSingolare", "Plurale": "TipoNumeroPronomeVolgare:PronomeVolgarePlurale" },
		"Classe_Persona": {
			"1ª": "TipoClassePersonaPronomeVolgare:PronomeVolgarePrimaClassePersona",
			"2ª": "TipoClassePersonaPronomeVolgare:PronomeVolgareSecondaClassePersona",
			"3ª": "TipoClassePersonaPronomeVolgare:PronomeVolgareTerzaClassePersona"
		},
		"Tipo": {
			"Personale": "TipoDelPronomeVolgare:PronomePersonaleVolgare",
			"Riflessivo": "TipoDelPronomeVolgarePronomeRiflessivoVolgare",
			"Interrogativo": "TipoDelPronomeVolgare:PronomeInterrogativoVolgare",
			"Esclamativo": "TipoDelPronomeVolgare:PronomeEsclamativoVolgare",
			"Dimostrativo": "TipoDelPronomeVolgare:PronomeDimostrativoVolgare",
			"Relativo": "TipoDelPronomeVolgare:PronomeRelativoVolgare",
			"Possessivo": "TipoDelPronomeVolgare:PronomePossessivoVolgare"
		},
		"Forma_Personali_Riflessivi": {
			"Libero": "TipoFormaPerRifPronomeVolgare:PronomeLiberoVolgare",
			"Libero in Composizione": "TipoFormaPerRifPronomeVolgare:PronomeLiberoInComposizioneVolgare",
			"Proclitico": "TipoFormaPerRifPronomeVolgare:PronomeProcliticoVolgare", "Enclitico": "TipoFormaPerRifPronomeVolgare:PronomeEncliticoVolgare"
		},
		"Funzione_Personali": {
			"Libero - soggetto": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoSoggetto",
			"Libero - soggetto impersonale": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoSoggettoImpersonale",
			"Libero - complemento": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoComplemento", "Libero - rafforzativo": "TipoFunzionePronomeVolgare:PronomeVolgareLiberoRafforzativo",
			"Clitico - accusativo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoAccusativo", "Clitico - dativo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoDativo",
			"Clitico - partitivo": "TipoFunzionePronomeVolgare:PronomeVolgareCliticoPartitivo"
		},
		"Tipo_Riflessivi": {
			"Proprio": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareProprio", "Lessicalizzato": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareLessicalizzato",
			"Impersonale": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareImpersonale", "Passivo": "TipoRiflessiviDelPronomeVolgare:PronomeVolgarePassivo",
			"Reciproco": "TipoRiflessiviDelPronomeVolgare:PronomeVolgareReciproco"
		}

	},

	"aggettivovolgare": {
		"Classe": { "1ª": "TipoClasseAggettivoVolgare:AggettivoVolgarePrimaClasse", "2ª": "TipoClasseAggettivoVolgare:AggettivoVolgareSecondaClasse" },
		"Genere": { "Femminile": "TipoGenereAggettivoVolgare:AggettivoVolgareFemminile", "Maschile": "TipoGenereAggettivoVolgare:AggettivoVolgareMaschile" },
		"Numero": { "Singolare": "TipoNumeroAggettivoVolgare:AggettivoVolgareSingolare", "Plurale": "TipoNumeroAggettivoVolgare:AggettivoVolgarePlurale" },
		"Con_oggetto_indiretto": { "Con oggetto indiretto": "AggettivoVolgareConOggettoIndiretto:AggettivoVolgareConOggettoIndiretto" },
		"Tipo_aggettivo": {
			"Qualificativo": "TipoDellAggettivoVolgare:AggettivoQualificativoVolgare",
			"Indefinito": "TipoDellAggettivoVolgare:AggettivoIndefinitoVolgare", "Interrogativo": "TipoDellAggettivoVolgare:AggettivoInterrogativoVolgare",
			"Esclamativo": "TipoDellAggettivoVolgare:AggettivoEsclamativoVolgare", "Numerale": "TipoDellAggettivoVolgare:AggettivoNumeraleVolgare",
			"Dimostrativo": "TipoDellAggettivoVolgare:AggettivoDimostrativoVolgare", "Relativo": "TipoDellAggettivoVolgare:AggettivoRelativoVolgare",
			"Possessivo": "TipoDellAggettivoVolgare:AggettivoPossessivoVolgare", "In locuzione": "TipoDellAggettivoVolgare:AggettivoVolgareInLocuzione"
		},
		"Grado": {
			"Comparativo di maggioranza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiMaggioranza", "Comparativo di minoranza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiMinoranza",
			"Comparativo di uguaglianza": "TipoGradoAggettivoVolgare:AggettivoVolgareComparativoDiUgualianza", "Superlativo relativo": "TipoGradoAggettivoVolgare:AggettivoVolgareSuperlativorelativo",
			"Superlativo assoluto": "TipoGradoAggettivoVolgare:AggettivoVolgareSuperlativoAssoluto"
		},
		"Tipo_di_Complemento": {
			"Introdotto da A": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaA", "Introdotto da CON": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaCON",
			"Introdotto da CONTRO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaCONTRO", "Introdotto da DA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDA",
			"Introdotto da DI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDI", "Introdotto da IN": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaIN",
			"Introdotto da PER": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaPER", "Introdotto da SU": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSU",
			"Introdotto da TRA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaTRA", "Introdotto da VERSO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaVERSO",
			"Introdotto da SOPRA": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSOPRA", "Introdotto da SOTTO": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaSOTTO",
			"Introdotto da DINANZI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaDINANZI", "Introdotto da prep.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareIntrodottoDaPreposizione",
			"Oggetto ind.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoInd", "Ogg. indi. + compl. con DI": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoIndComplConDI",
			"Ogg. ind. pronom.": "TipoDiCompelementoAggettivoVolgare:AggettivoVolgareOggettoIndPronom"
		},
		"Tipo_di_frase": {
			"Con infinito retto da A": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaA", "Con infinito retto da DA": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaDA",
			"Con infinito retto da DI": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaDI", "Con infinito retto da PER": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaPER",
			"Con infinito retto da SE": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConInfinitoRettoDaSE", "Con subordinata all'indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConSubordinataAllIndicativo",
			"Con subordinata al cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareConSubordinataAlCongiuntivo", "In locuzione imp.+infinito": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpInfinito",
			"In locuzione imp.+che+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpCheIndicativo", "In locuzione imp.+che+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpCheCongiuntivo",
			"In locuzione imp.+se+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpSeIndicativo", "In locuzione imp.+se+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpSeCongiuntivo",
			"In locuzione imp.+come+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpComeIndicativo", "In locuzione imp.+quando+indic.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpQuandoIndicativo",
			"In locuzione imp.+perché+cong.": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpPerchéCongiuntivo", "In locuzione imp.+a+infinito": "TipoDiFraseAggettivoVolgare:AggettivoVolgareInLocuzioneImpAInfinito"
		}

	},

	"articolovolgare": {
		"Genere": { "Femminile": "TipoGenereArticoloVolgare:ArticoloVolgareFemminile", "Maschile": "TipoGenereArticoloVolgare:ArticoloVolgareMaschile" },
		"Numero": { "Singolare": "TipoNumeroArticoloVolgare:ArticoloVolgareSingolare", "Plurale": "TipoNumeroArticoloVolgare:ArticoloVolgarePlurale" },
		"Tipo": { "Determinativo": "TipoDellArticoloVolgare:ArticoloVolgareDeterminativo", "Indeterminativo": "TipoDellArticoloVolgare:ArticoloVolgareIndeterminativo" }

	},
	"avverbiovolgare": {
		"Tipo": {
			"Al comparativo di maggioranza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiMaggioranza",
			"Al comparativo di minoranza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiMinoranza",
			"Al superlativo assoluto": "TipoDellAvverbioVolgare:AvverbioVolgareAlSuperlativoAssoluto",
			"Al superlativo relativo": "TipoDellAvverbioVolgare:AvverbioVolgareAlSuperlativoRelativo",
			"In Locuzione": "TipoDellAvverbioVolgare:AvverbioVolgareInLocuzione",
			"In Locuzione separato": "TipoDellAvverbioVolgare:AvverbioVolgareInLocuzioneSeparato",
			"Proclitico": "TipoDellAvverbioVolgare:AvverbioVolgareProclitico",
			"Enclitico": "TipoDellAvverbioVolgare:AvverbioVolgareEnclitico",
			"Al comparativo di ugualianza": "TipoDellAvverbioVolgare:AvverbioVolgareAlComparativoDiUgualianza"
		}
	},

	"preposizionevolgare": {
		"Tipo_I": {
			"Propria": "TipoIDellaPreposizioneVolgare:PreposizioneVolgarePropria",
			"Impropria": "TipoIDellaPreposizioneVolgare:PreposizioneVolgareImpropria"
		},
		"Tipo_preposizione": {
			"Semplice": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareSemplice",
			"Articolata": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareArticolata",
			"In locuzione": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareInLocuzione",
			"In locuzione separata": "TipoIIDellaPreposizioneVolgare:PreposizioneVolgareInLocuzioneSeparata"
		},
		"Sintassi": {
			"Soggettiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareSoggettiva", "Oggettiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareOggettiva",
			"Dichiarativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareDichiarativa", "Completiva obliqua": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareCompletivaObliqua",
			"Finale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareFinale",
			"Causale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareCausale",
			"Concessiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareConcessiva",
			"Consecutiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareConsecutiva",
			"Temporale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareTemporale",
			"Modale": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareModale",
			"Eccettuativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareEccettuativa",
			"Esclusiva": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareEsclusiva",
			"Limitativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareLimitativa",
			"Comparativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareComparativa",
			"Avversativa": "TipoSintassiPreposizioneVolgare:PreposizioneVolgareAvversativa"
		},
		"Complemento_(I)": {
			"Di stato in luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiStatoInLuogo",
			"Di moto a luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoALuogo",
			"Di moto da luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoDaLuogo",
			"Di moto per luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMotoPerLuogo",
			"Di luogo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiLuogo",
			"Predicativo del soggetto": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgarePredicativoDelSoggetto",
			"Predicativo dell'oggetto": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgarePredicativoDellOggetto",
			"Di distanza": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiDistanza",
			"Di tempo determinato": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempoDeterminato",
			"Di tempo continuato": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempoContinuato",
			"Di tempo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTempo",
			"Di termine": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiTermine",
			"Di vantaggio": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiVantaggio",
			"Di svantaggio": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiSvantaggio",
			"Di specificazione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiSpecificazione",
			"Di modo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiModo",
			"Di mezzo": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMezzo",
			"Di compagnia": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiCompagnia",
			"Di unione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiUnione",
			"Di allontanamento-separazione": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiAllontanamentoSeparazione",
			"Di materia": "TipoComplementoIPreposizioneVolgare:PreposizioneVolgareDiMateria"
		},
		"Complemento_(II)": {
			"Di limitazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiLimitazione",
			"Di qualità": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiQualità",
			"Di causa": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiCausa",
			"Di agente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiAgente",
			"Di causa efficiente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiCausaEfficiente",
			"Di fine o scopo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiFineScopo",
			"Di paragone": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiParagone",
			"Di argomento": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiArgomento",
			"Distributivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDistributivo",
			"Di sostituzione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiSostituzione",
			"Di estensione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEstensione",
			"Di rapporto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiRapporto",
			"Di esclusione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEsclusione",
			"Di peso": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiPeso",
			"Di quantità": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiQuantità",
			"Di colpa": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiColpa",
			"Di denominazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiDenominazione",
			"partitivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgarePartitivo",
			"Di abbondanza-privazione": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiAbbondanzaPrivazione",
			"Di origine-provenienza": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiOrigineProvenienza",
			"Concessivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareConcessivo",
			"Di effetto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiEffetto",
			"Di pena": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareDiPena",
			"Simmetrico": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareSimmetrico",
			"Indiretto esperiente": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoEsperiente",
			"Indiretto dativo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoDativo",
			"Indiretto oggetto": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoOggetto",
			"Indiretto possessore": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoPossessore",
			"Indiretto benefattivo": "TipoComplementoIIPreposizioneVolgare:PreposizioneVolgareIndirettoBenefattivo"
		}
	},

	"congiunzionevolgare": {
		"Coo_sub": {
			"Coordinativa": "TipoCooSubCongiunzioneVolgare:CongiunzioneVolgareCoordinativa",
			"Subordinativa": "TipoCooSubCongiunzioneVolgare:CongiunzioneVolgareSubordinativa"
		},
		"Tipo": {
			"Semplice": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareSemplice",
			"Composta": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareComposta",
			"Locuzione": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareLocuzione",
			"Locuzione separata": "TipoDellaCongiunzioneVolgare:CongiunzioneVolgareLocuzioneSeparata"
		},
		"Coord_tipo": {
			"Copulativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareCopulativa",
			"Disgiuntiva": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareDisgiuntiva",
			"Avversativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareAvversativa",
			"Esplicativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareEsplicativa",
			"Conclusiva": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareConclusiva",
			"Correlativa": "TipoDellaCoordinativaCongiunzioneVolgare:CongiunzioneVolgareCorrelativa"
		},
		"Subord_tipo": {
			"Soggettiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareSoggettiva",
			"Oggettiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareOggettiva",
			"Dichiarativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareDichiarativa",
			"Completiva obliqua": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCompletivaObliqua",
			"Interrogativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareInterrogativa",
			"Finali": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareFinali",
			"Causali": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCausali",
			"Concessiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareConcessiva",
			"Consecutiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareConsecutiva",
			"Temporale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareTemporale",
			"Modale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareModale",
			"Eccettuativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareEccettuativa",
			"Comparativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareComparativa",
			"Condizionale": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareCondizionale",
			"Esclusiva": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareEsclusiva",
			"Limitativa": "TipoDellaSubordinativaCongiunzioneVolgare:CongiunzioneVolgareLimitativa"
		}
	},

	"onomasticavolgare": {
		"Tipo": {
			"Nome proprio": "TipoDellOnomasticaVolgare:NomeProprio", "Nome proprio separato": "TipoDellOnomasticaVolgare:NomeProprioSeparato",
			"Titolo": "TipoDellOnomasticaVolgare:Titolo"
		}
	},

	"citazionevolgare": {
		"Tipo": {
			"Latina": "TipoDellaCitazioneVolgare:CitazioneLatina",
			"Provenzale": "TipoDellaCitazioneVolgare:CitazioneProvenzale",
			"Francese": "TipoDellaCitazioneVolgare:CitazioneFrancese",
			"Spagnola": "TipoDellaCitazioneVolgare:CitazioneSpagnola",
			"Ebraica": "TipoDellaCitazioneVolgare:CitazioneEbraica",
			"Greca": "TipoDellaCitazioneVolgare:CitazioneGreca"
		}

	}
}

/*
*
* SPARQL statements
*
*/
data21 = `{"verbovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaVerboVolgare"}},
	"sostantivovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaSostantivoVolgare"}},
	"aggettivovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaAggettivoVolgare"}},
	"avverbiovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaAvverbioVolgare"}},
	"pronomevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaPronomeVolgare"}},
	"congiunzionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaCongiunzioneVolgare"}},
	"articolovolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaArticoloVolgare"}},
	"preposizionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaPreposizioneVolgare"}},
	"interiezionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaInteriezioneVolgare"}},
	"onomasticavolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaOnomasticaVolgare"}},
	"citazionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaCitazioneVolgare"}}, 
	"locuzionevolgare": {"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"}, "object": {"termType": "NamedNode", "value": "https://dantenetwork.it/ontology/orl/current/FormaLocuzioneVolgare"}}
	}
	`

writtenrepresentation = `{"subject": {"termType": "Variable", "value":"form"}, "predicate": {"termType":"NamedNode", "value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"}, "object": {"termType": "Variable", "value": "Rappresentazione"}}`


var morphgroup = `{"type": "group",
 			 "patterns": [{"type": "bgp",
                           "triples": [
				                    {"subject": {"termType": "Variable","value": "form"},
				                     "predicate": {"termType": "NamedNode", "value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"},
				                     "object": {"termType": "Variable","value": "Rappresentazione"}},
				                    {"subject": {"termType": "Variable","value": "lent"},
				                     "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#lexicalForm"},
				                     "object": {"termType": "Variable", "value": "form"}},
				                    {"subject": {"termType": "Variable","value": "lent"},
				                     "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#canonicalForm"},
				                     "object": {"termType": "Variable","value": "cf"}},
				                    {"subject": {"termType": "Variable","value": "cf"},
				                     "predicate": {"termType": "NamedNode","value": "http://www.w3.org/ns/lemon/ontolex#writtenRep"},
				                     "object": {"termType": "Variable","value": "lm"}},
				                    {"subject": {"termType": "Variable","value": "fa"},
				                     "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occurrenceOf"},
				                     "object": {"termType": "Variable","value": "form"}},
				                    {"subject": {"termType": "Variable","value": "fa"},
				                     "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/OccursInRegion"},
				                     "object": {"termType": "Variable", "value": "reg"}},
				                    {"subject": {"termType": "Variable","value": "reg"},
				                     "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionFrom"},
				                     "object": {"termType": "Variable","value": "pos1"}}
				                    ]
				            }
        				]
    		}
`
var syntgroup = ` {
        		"type": "group",
        		"patterns": [
            				{
                			"type": "bgp",
                			"triples": [
                    					{"subject": {"termType": "Variable","value": "clocc"},
                        				"predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occurrenceOf"},
                        				"object": {"termType": "Variable","value": "cl"}},
                    				   {"subject": {"termType": "Variable","value": "clocc"},
                                        "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P148_has_component"},
                                        "object": {"termType": "Variable","value": "fa"}},
                                       {"subject": {"termType": "Variable","value": "clocc"},
                                        "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/occursInRegion"},
                                        "object": {"termType": "Variable","value": "frag"}},
                                      {"subject": {"termType": "Variable","value": "sentence"},
                                       "predicate": {"termType": "NamedNode","value": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"},
                                       "object": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/Sentence"}},
                                      {"subject": {"termType": "Variable","value": "sentence"},
                                       "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P148i_is_component_of"},
                                       "object": {"termType": "Variable","value": "canto"}},
                                      {"subject": {"termType": "Variable","value": "sentence"},
                                       "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasSyntacticalComponent"},
                                       "object": {"termType": "Variable","value": "cl"}},
                    				 {"subject": {"termType": "Variable","value": "cl"},
                                      "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasClauseType"},
                                      "object": {"termType": "Variable","value": "clatype"}},
                                     {"subject": {"termType": "Variable","value": "cl"},
                                      "predicate": {"termType": "NamedNode","value": "http://erlangen-crm.org/current/P190_has_symbolic_content"},
									  "object": {"termType": "Variable","value": "cltext"}},
                    				{"subject": {"termType": "Variable","value": "cl"},
                    				 "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/syntit/current/hasClauseFunction"},
                                     "object": {"termType": "Variable","value": "clafunction"}},
                    			   {"subject": {"termType": "Variable","value": "frag"},
                                    "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionFrom"},
                                   "object": {"termType": "Variable","value": "clfr"}},
                    			  {"subject": {"termType": "Variable","value": "frag"},
                                   "predicate": {"termType": "NamedNode","value": "https://dantenetwork.it/ontology/olires/current/fragmentRegionTo"},
                                   "object": {"termType": "Variable","value": "clto"}}
                                 ]
                      }
                      ]
      }

`
/*
*
*Tipi sintattici
*
*/

var funzione_clausola =
{
	"princ": "hasClauseFunction:MainClause",
	"subord i": "hasClauseFunction:SubordinateClauseI",
	"subord ii": "hasClauseFunction:SubordinateClauseII",
	"subord iii": "hasClauseFunction:SubordinateClauseIII",
	"subord iv": "hasClauseFunction:SubordinateClauseIV",
	"subord v": "hasClauseFunction:SubordinateClauseV",
	"subord vi": "hasClauseFunction:SubordinateClauseVI",
	"subord vii": "hasClauseFunction:SubordinateClauseVII",
	"coord": "hasClauseFunction:CoordinateClause",
	"coord i": "hasClauseFunction:CoordinateClauseI",
	"coord ii": "hasClauseFunction:CoordinateClauseII",
	"coord iii": "hasClauseFunction:CoordinateClauseIII",
	"coord iv": "hasClauseFunction:CoordinateClauseIV",
	"coord v": "hasClauseFunction:CoordinateClauseV",
	"pcoord": "hasClauseFunction:ParentheticalCoordinateClause",
	"parent": "hasClauseFunction:ParentethicalClause",
	"coord 0": "hasClauseFunction:PseudoCoordinateClause"
}

//da completare

var listaMacroTipiConSubTipo = ['Concessiva', 'Comparativa', 'Ipotetica', 'Interrogativa', 'Iussiva', 'Ottativa', 'Avversativa', 'Relativa']

var macrotipi_sint =
{
	"macro avv": "hasClauseType:Avversativa",
	"avv": "hasClauseType:Avversativa",
	"macro caus": "hasClauseType:Causale",
	"macro compar": "hasClauseType:Comparativa",
	"macro conces": "hasClauseType:Concessiva",
	"macro consec": "hasClauseType:Consecutiva",
	"macro dich": "hasClauseType:Dichiarativa",
	"macro eccettu": "hasClauseType:Eccettuativa",
	"macro epesege": "hasClauseType:Epesegetica",
	"macro escl": "hasClauseType:Esclamativa",
	"macro esclu": "hasClauseType:Esclusiva",
	"macro finale": "hasClauseType:Finale",
	"macro inter princ": "hasClauseType:Interrogativa",
	"macro inter sub": "hasClauseType:Interrogativa",
	"macro ipotet": "hasClauseType:Ipotetica",
	"macro iussi": "hasClauseType:Iussiva",
	"macro limitat": "hasClauseType:Limitativa",
	"macro maniera": "hasClauseType:DiManiera",
	"macro modale": "hasClauseType:Modale",
	"macro obliqua": "hasClauseType:Obliqua",
	"macro oggettiva": "hasClauseType:Oggettiva",
	"macro otta": "hasClauseType:Ottativa",
	//"macro pare mod": "hasClauseType:ParenteticaModalizzante",
	//"macro pare sub": "hasClauseType:ParenteticaConValoreDiSubordinata",
	"macro pare mod": "hasClauseType:Modalizzante;hasClauseFunction:ParentethicalClause",
	"macro pare sub": "hasClauseType:Subordinata;hasClauseFunction:ParentethicalClause",
	"macro pred": "hasClauseType:Predicativa",
	//"macro pseudo": "hasClauseType:Pseudocoordinata",
	"macro pseudo": "hasClauseFunction:ParentheticalCoordinateClause",
	"macro rel": "hasClauseType:Relativa",
	"macro sog": "hasClauseType:Soggettiva",
	"macro strum": "hasClauseType:Strumentale",
	//"macro sub": "hasClauseType:SubordinataConFunzioneDiRipresa",
	"macro sub": "hasClauseFunction:SubordinateClauseI;hasClauseType:FunzioneDiRipresa",
	"macro temp": "hasClauseType:Temporale"
}

var tipi_sint =
{
	"avv caus": "hasClauseType:CoordinataAvversativaCausale",
	"avv comp ug": "hasClauseType:CoordinataAvversativaComparativaDiUguaglianza",
	"avv cons antec": "hasClauseType:CoordinataAvversativaConsecutivaConAntecedente",
	"avv dich": "hasClauseType:CoordinataAvversativaDichiarativa",
	"avv fin": "hasClauseType:CoordinataAvversativaFinale",
	"avv int x": "hasClauseType:CoordinataAvversativaInterrogativaDiTipoX",
	"avv int x ret": "hasClauseType:CoordinataAvversativaInterrogativaDiTipoXRetorica",
	"avv ipo caus": "hasClauseType:CoordinataAvversativaIpoteticaConValoreCausale",
	"avv iuss dir": "hasClauseType:CoordinataAvversativaIussivaDiretta",
	"avv iuss indir": "hasClauseType:CoordinataAvversativaIussivaIndiretta",
	"avv modaliz ott intr": "hasClauseType:CoordinataAvversativaModalizzanteOttativaConIntroduttore",
	"avv ogg": "hasClauseType:CoordinataAvversativaOggettiva",
	"avv ogg perc": "hasClauseType:CoordinataAvversativaOggettiva",
	"avv rel app": "hasClauseType:CoordinataAvversativaRelativaAppositiva",
	"avv rel app comp ug": "hasClauseType:CoordinataAvversativaRelativaAppositivaInConstruttoComparativo",
	"avv rel app cons antec": "hasClauseType:CoordinataAvversativaRelativaAppositivaConValoreConsecutivo",
	"avv rel giust": "hasClauseType:CoordinataAvversativaRelativaGiustapposta",
	"avv rel ind": "hasClauseType:CoordinataAvversativaRelativaIndipendente",
	"avv rel ind temp": "hasClauseType:CoordinataAvversativaRelativaIndipendenteTemporale",
	"avv rel restr": "hasClauseType:CoordinataAvversativaRelativaRestrittiva",
	"avv rel restr comp ug": "hasClauseType:CoordinataAvversativaRelativaRestrittivaInCostruttoComparativo",
	"avv sogg": "hasClauseType:CoordinataAvversativaSoggettiva",
	"avv temp": "hasClauseType:CoordinataAvversativaTemporale",
	"comp disug": "hasClauseType:ComparativaDiDisuguaglianza",
	"comp disug ipo": "hasClauseType:ComparativaDiDisuguaglianzaConValoreIpotetico",
	"comp fin": "hasClauseType:ComparativaConValoreFinale",
	"comp ipo": "hasClauseType:ComparativaConValoreIpotetico",
	"comp lim": "hasClauseType:ComparativaConValoreLimitativo",
	"comp mod": "hasClauseType:ComparativaConValoreModale",
	"comp temp": "hasClauseType:ComparativaConValoreTemporale",
	"comp ug": "hasClauseType:ComparativaDiUguaglianza",
	"comp ug rel ind temp": "hasClauseType:ComparativaDiUguaglianzaConValoreDiRelativaIndipendenteTemporale",
	"conc acond": "hasClauseType:ConcessivaAcondizionale",
	"conc cond": "hasClauseType:ConcessivaCondizionale",
	"conc fatt": "hasClauseType:ConcessivaFattuale",
	"cong asind comp ug": "hasClauseType:CoordinataAsindeticaComparativaDiUguaglianza",
	"cong asind cons antec": "hasClauseType:CoordinataAsindeticaConsecutivaConAntecedente",
	"cong asind dich": "hasClauseType:CoordinataAsindeticaDichiarativa",
	"cong asind epes": "hasClauseType:CoordinataAsindeticaEpesegetica",
	"cong asind esclam": "hasClauseType:CoordinataAsindeticaEsclamativa",
	"cong asind fin": "hasClauseType:CoordinataAsindeticaFinale",
	"cong asind int altern": "hasClauseType:CoordinataAsindeticaInterrogativaAlternativa",
	"cong asind int altern ret": "hasClauseType:CoordinataAsindeticaInterrogativaAlternativaRetorica",
	"cong asind int disg": "hasClauseType:CoordinataAsindeticaInterrogativaDisgiuntiva",
	"cong asind int x": "hasClauseType:CoordinataAsindeticaInterrogativaDiTipoX",
	"cong asind int x ret": "hasClauseType:CoordinataAsindeticaInterrogativaDiTipoXRetorica",
	"cong asind ipo": "hasClauseType:CoordinataAsindeticaIpotetica",
	"cong asind iuss dir": "hasClauseType:CoordinataAsindeticaIussivaDiretta",
	"cong asind iuss indir": "hasClauseType:CoordinataAsindeticaIussivaIndiretta",
	"cong asind man": "hasClauseType:CoordinataAsindeticaDiManiera",
	"cong asind ogg": "hasClauseType:CoordinataAsindeticaOggettiva",
	"cong asind ogg perc": "hasClauseType:CoordinataAsindeticaOggettiva",
	"cong asind ott intr": "hasClauseType:CoordinataAsindeticaOttativaConIntroduttore",
	"cong asind ott libera": "hasClauseType:CoordinataAsindeticaOttativaLibera",
	"cong asind rel app": "hasClauseType:CoordinataAsindeticaRelativaAppositiva",
	"cong asind rel app comp disug": "hasClauseType:CoordinataAsindeticaRelativaAppositivaInConstruttoComparativo",
	"cong asind rel app giust": "hasClauseType:CoordinataAsindeticaRelativaGiustapposta",
	"cong asind rel ind": "hasClauseType:CoordinataAsindeticaRelativaIndipendente",
	"cong asind rel ind temp caus": "hasClauseType:CoordinataAsindeticaRelativaIndipendenteConValoreTemporaleCausale",
	"cong asind rel restr": "hasClauseType:CoordinataAsindeticaRelativaRestrittiva",
	"cong asind rel restr comp ug": "hasClauseType:CoordinataAsindeticaRelativaRestrittivaInConstruttoComparativo",
	"cong asind sogg soll": "hasClauseType:CoordinataAsindeticaSoggettivaASollevamento",
	"cong asind subord": "hasClauseType:CoordinataAsindeticaSubordinata",
	"cong asind temp": "hasClauseType:CoordinataAsindeticaTemporale",
	"cong caus": "hasClauseType:CoordinataCongiuntivaCausale",
	"cong comp disug": "hasClauseType:CoordinataCongiuntivaComparativaDiDisuguaglianza",
	"cong comp ipo": "hasClauseType:CoordinataCongiuntivaComparativaConValoreIpotetico",
	"cong comp lim": "hasClauseType:CoordinataCongiuntivaComparativaConValoreLimitativo",
	"cong comp mod": "hasClauseType:CoordinataCongiuntivaComparativaConValoreModale",
	"cong comp ug": "hasClauseType:CoordinataCongiuntivaComparativaDiUguaglianza",
	"cong conc cond": "hasClauseType:CoordinataCongiuntivaConcessivaCondizionale",
	"cong conc fatt": "hasClauseType:CoordinataCongiuntivaConcessivaFattuale",
	"cong concl cons antec": "hasClauseType:CoordinataConclusivaConsecutivaConAntecedente",
	"cong concl dich": "hasClauseType:CoordinataConclusivaDichiarativa",
	"cong concl dich ill": "hasClauseType:CoordinataConclusivaDichiarativaIllocutiva",
	"cong concl iuss dir": "hasClauseType:CoordinataConclusivaIussivaDiretta",
	"cong concl iuss dir perifr": "hasClauseType:CoordinataConclusivaIussivaDirettaPerifrastica",
	"cong concl iuss indir": "hasClauseType:CoordinataConclusivaIussivaIndiretta",
	"cong cons antec": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedente",
	"cong cons antec epes": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedenteEpisegetica",
	"cong cons antec fin": "hasClauseType:CoordinataCongiuntivaConsecutivaConAntecedenteConValoreFinale",
	"cong cons caus": "hasClauseType:CoordinataConsecutivaCausale",
	"cong cons dich": "hasClauseType:CoordinataConsecutivaDichiarativa",
	"cong cons ell": "hasClauseType:CoordinataCongiuntivaConsecutivaEllittica",
	"cong cons libera": "hasClauseType:CoordinataCongiuntivaConsecutivaLibera",
	"cong cons libera fin": "hasClauseType:CoordinataCongiuntivaConsecutivaLiberaConValoreFinale",
	"cong cons post": "hasClauseType:CoordinataCongiuntivaConsecutivaPosposta",
	"cong corr dich": "hasClauseType:CoordinataCorrelativaDichiarativa",
	"cong corr fin": "hasClauseType:CoordinataCorrelativaFinale",
	"cong corr lim": "hasClauseType:CoordinataCorrelativaLimitativa",
	"cong corr sogg infinitoprep": "hasClauseType:CoordinataCorrelativaSoggettivaAInfinitoPreposizionale",
	"cong dich": "hasClauseType:CoordinataCongiuntivaDichiarativa",
	"cong dich ill": "hasClauseType:CoordinataCongiuntivaDichiarativaIllocutiva",
	"cong eccett": "hasClauseType:CoordinataCongiuntivaEccettuativa",
	"cong epes": "hasClauseType:CoordinataCongiuntivaEpesegetica",
	"cong esclam": "hasClauseType:CoordinataCongiuntivaEsclamativa",
	"cong esclus": "hasClauseType:CoordinataCongiuntivaEsclusiva",
	"cong espl dich": "hasClauseType:CoordinataEsplicativaDichiarativa",
	"cong espl obl": "hasClauseType:CoordinataEsplicativaObliqua",
	"cong espl ogg": "hasClauseType:CoordinataEsplicativaOggettiva",
	"cong espl rel app antec": "hasClauseType:CoordinataEsplicativaRelativaAppositivaConAntecedente",
	"cong espl rel ind mod": "hasClauseType:CoordinataEsplicativaRelativaIndipendenteConValoreModale",
	"cong fin": "hasClauseType:CoordinataCongiuntivaFinale",
	"cong int altern": "hasClauseType:CoordinataCongiuntivaInterrogativaAlternativa",
	"cong int x": "hasClauseType:CoordinataCongiuntivaInterrogativaDiTipoX",
	"cong int x ret": "hasClauseType:CoordinataCongiuntivaInterrogativaDiTipoXRetorica",
	"cong ipo": "hasClauseType:CoordinataCongiuntivaIpotetica",
	"cong ipo caus": "hasClauseType:CoordinataCongiuntivaIpoteticaConValoreCausale",
	"cong ipo sogg": "hasClauseType:CoordinataCongiuntivaIpoteticaSoggettiva",
	"cong iuss dir": "hasClauseType:CoordinataCongiuntivaIussivaDiretta",
	"cong iuss indir": "hasClauseType:CoordinataCongiuntivaIussivaIndiretta",
	"cong lim": "hasClauseType:CoordinataCongiuntivaLimitativa",
	"cong man": "hasClauseType:CoordinataCongiuntivaDiManiera",
	"cong modaliz ott intr": "hasClauseType:CoordinataCongiuntivaModalizzanteOttativaConIntroduttore",
	"cong obl": "hasClauseType:CoordinataCongiuntivaObliqua",
	"cong ogg": "hasClauseType:CoordinataCongiuntivaOggettiva",
	"cong ogg perc": "hasClauseType:CoordinataCongiuntivaOggettiva",
	"cong ott libera": "hasClauseType:CoordinataCongiuntivaLibera",
	"cong rel app": "hasClauseType:CoordinataCongiuntivaRelativaAppositiva",
	"cong rel app comp disug": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaInCostruttoComparativoDiDisuguaglianza",
	"cong rel app comp ug": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaInCostruttoComparativoDiUguaglianza",
	"cong rel app cons": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreConsecutivo",
	"cong rel app epes": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreDiEpisegetica",
	"cong rel app fin": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreFinale",
	"cong rel app giust": "hasClauseType:CoordinataCongiuntivaRelativaGiustapposta",
	"cong rel app giust caus": "hasClauseType:CoordinataCongiuntivaRelativaGiustappostaConValoreCausale",
	"cong rel app temp": "hasClauseType:CoordinataCongiuntivaRelativaAppositivaConValoreTemporale",
	"cong rel impl": "hasClauseType:CoordinataCongiuntivaRelativaImplicita",
	"cong rel impl lim": "hasClauseType:CoordinataCongiuntivaRelativaImplicitaConValoreLimitativo",
	"cong rel ind": "hasClauseType:CoordinataCongiuntivaRelativaIndipendente",
	"cong rel ind acond": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteAcondizionale",
	"cong rel ind ipo": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteConValoreIpotetico",
	"cong rel ind mod": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteConValoreModale",
	"cong rel ind mod comp ug": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteInCostruttoComparativoModale",
	"cong rel ind temp": "hasClauseType:CoordinataCongiuntivaRelativaIndipendenteTemporale",
	"cong rel pseudo": "hasClauseType:CoordinataCongiuntivaPseudoRelativa",
	"cong rel restr": "hasClauseType:CoordinataCongiuntivaRelativaRestrittiva",
	"cong rel restr caus": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaConValoreCausale",
	"cong rel restr comp": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaInCostruttoComparativo",
	"cong rel restr comp ug": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaInCostruttoComparativoDiUguaglianza",
	"cong rel restr cons": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaConValoreConsecutivo",
	"cong rel restr temp": "hasClauseType:CoordinataCongiuntivaRelativaRestrittivaTemporale",
	"cong rip": "hasClauseType:CoordinataCongiuntivaConFunzioneDiRipresa",
	"cong sogg": "hasClauseType:CoordinataCongiuntivaSoggettiva",
	"cong spec": "hasClauseType:CoordinataCongiuntivaSpecificativa",
	"cong strum": "hasClauseType:CoordinataCongiuntivaStrumentale",
	"cong subord": "hasClauseType:CoordinataCongiuntivaSubordinata",
	"cong temp": "hasClauseType:CoordinataCongiuntivaTemporale",
	"cong temp caus": "hasClauseType:CoordinataCongiuntivaTemporaleConValoreCausale",
	"cons antec": "hasClauseType:ConsecutivaConAntecedente",
	"cons antec epes": "hasClauseType:ConsecutivaConAntecedenteEpesegetica",
	"cons antec fin": "hasClauseType:ConsecutivaConAntecedenteConValoreFinale",
	"cons antec temp": "hasClauseType:ConsecutivaConAntecedenteConValoreTemporale",
	"cons ell": "hasClauseType:ConsecutivaEllittica",
	"cons libera": "hasClauseType:ConsecutivaLibera",
	"cons libera fin": "hasClauseType:ConsecutivaLiberaConValoreFinale",
	"cons post": "hasClauseType:ConsecutivaPosposta",
	"dich": "hasClauseType:Dichiarativa",
	"dich ill": "hasClauseType:DichiarativaIllocutiva",
	"disg comp disug temp": "hasClauseType:CoordinataDisgiuntivaComparativaDiDisuguaglianzaConValoreTemporale",
	"disg conc acond": "hasClauseType:CoordinataDisgiuntivaConcessivaAcondizionale",
	"disg conc cond": "hasClauseType:CoordinataDisgiuntivaConcessivaCondizionale",
	"disg cons libera": "hasClauseType:CoordinataDisgiuntivaConsecutivaLibera",
	"disg corr dich": "hasClauseType:CoordinataDisgiuntivaCorrelativaDichiarativa",
	"disg dich": "hasClauseType:CoordinataDisgiuntivaDichiarativa",
	"disg epes": "hasClauseType:CoordinataDisgiuntivaEpesegetica",
	"disg esclus": "hasClauseType:CoordinataDisgiuntivaEsclusiva",
	"disg int altern": "hasClauseType:CoordinataDisgiuntivaInterrogativaAlternativa",
	"disg int disg": "hasClauseType:CoordinataDisgiuntivaInterrogativaDisgiuntiva",
	"disg int x": "hasClauseType:CoordinataDisgiuntivaInterrogativaDiTipoX",
	"disg ipo": "hasClauseType:CoordinataDisgiuntivaIpotetica",
	"disg lim": "hasClauseType:CoordinataDisgiuntivaLimitativa",
	"disg man": "hasClauseType:CoordinataDisgiuntivaDiManiera",
	"disg obl": "hasClauseType:CoordinataDisgiuntivaObliqua",
	"disg ogg": "hasClauseType:CoordinataDisgiuntivaOggettiva",
	"disg rel ind": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendente",
	"disg rel ind acond": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendenteAcondizionale",
	"disg rel ind temp": "hasClauseType:CoordinataDisgiuntivaRelativaIndipendenteTemporale",
	"disg rel restr": "hasClauseType:CoordinataDisgiuntivaRestrittiva",
	"disg rel restr cons": "hasClauseType:CoordinataDisgiuntivaRestrittivaConValoreConsecutivo",
	"disg sogg": "hasClauseType:CoordinataDisgiuntivaSoggettiva",
	"disg temp": "hasClauseType:CoordinataDisgiuntivaTemporale",
	"eccett": "hasClauseType:Eccettuativa",
	"eccett comp ug": "hasClauseType:EccettuativaConValoreDiComparativaDiUguaglianza",
	"epes": "hasClauseType:Epesegetica",
	"esclam": "hasClauseType:Esclamativa",
	"esclus": "hasClauseType:Esclusiva",
	"faltern": "hasClauseType:FalsaAlternativa",
	"fcong": "hasClauseType:FalsaCongiuntiva",
	"fin": "hasClauseType:Finale",
	"fin ipo": "hasClauseType:FinaleConValoreIpotetico",
	"fin rel giust": "hasClauseType:ConcorrenzaDelRelativoInFraseFinale",
	"int altern": "hasClauseType:InterrogativaAlternativa",
	"int altern ret": "hasClauseType:InterrogativaAlternativaRetorica",
	"int disg": "hasClauseType:InterrogativaDisgiuntiva",
	"int disg ret": "hasClauseType:InterrogativaDisgiuntivaRetorica",
	"int x": "hasClauseType:InterrogativaDiTipoX",
	"int x ret": "hasClauseType:InterrogativaDiTipoXRetorica",
	"ipo": "hasClauseType:Ipotetica",
	"ipo biaff": "hasClauseType:IpoteticaBiaffermativa",
	"ipo caus": "hasClauseType:IpoteticaConValoreCausale",
	"ipo eccett": "hasClauseType:IpoteticaConValoreEccettuativo",
	"ipo obl": "hasClauseType:IpoteticaObliqua",
	"ipo rel giust": "hasClauseType:IpoteticaRelativaGiustapposta",
	"ipo sogg": "hasClauseType:IpoteticaSoggettiva",
	"iuss aug": "hasClauseType:IussivaAugurativa",
	"iuss dir": "hasClauseType:IussivaDiretta",
	"iuss dir perifr": "hasClauseType:IussivaDirettaPerifrastica",
	"iuss indir": "hasClauseType:IussivaIndiretta",
	"lim": "hasClauseType:Limitativa",
	"lim caus": "hasClauseType:LimitativaConValoreCausale",
	"lim caus eccett": "hasClauseType:LimitativaConValoreCausaleEccettuativo",
	"lim eccett": "hasClauseType:LimitativaConValoreEccettuativo",
	"man": "hasClauseType:DiManiera",
	"man gerundioprep": "hasClauseType:DiManieraAGerundioPreposizionale",
	"man rel giust": "hasClauseType:ConcorrenzaDelRelativoInFraseDiManiera",
	"mod": "hasClauseType:Modale",
	"modaliz": "hasClauseType:Modalizzante",
	"modaliz ott intr": "hasClauseType:ModalizzanteOttativaConIntroduttore",
	"modalizz ott libera": "hasClauseType:ModalizzanteOttativaLibera",
	"obl": "hasClauseType:Obliqua",
	"ogg": "hasClauseType:Oggettiva",
	"ogg aci": "hasClauseType:Oggettiva",
	"ogg perc": "hasClauseType:Oggettiva",
	"ott intr": "hasClauseType:OttativaConIntroduttore",
	"ott libera": "hasClauseType:OttativaLibera",
	"pred": "hasClauseType:Predicativa",
	"rel app antec": "hasClauseType:RelativaAppositivaConAntecedente",
	"rel app antec caus": "hasClauseType:RelativaAppositivaConAntecedenteConValoreCausale",
	"rel app antec comp disug": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoComparativoDiDisuguaglianza",
	"rel app antec comp ug": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoComparativoDiUguaglianza",
	"rel app antec comp ug": "hasClauseType:RelativaConAntecedenteInCostruttoComparativoDiUguaglianza",
	"rel app antec cons": "hasClauseType:RelativaAppositivaConAntecedenteConValoreConsecutivo",
	"rel app antec eccett": "hasClauseType:RelativaAppositivaConAntecedenteInCostruttoEccettuativo",
	"rel app antec fin": "hasClauseType:RelativaAppositivaConAntecedenteConValoreFinale",
	"rel app antec fin cons": "hasClauseType:RelativaAppositivaConAntecedenteConValoreConsecutivoFinale",
	"rel app antec giust": "hasClauseType:RelativaAppositivaConAntecedenteGiustapposta",
	"rel app antec giust cons": "hasClauseType:RelativaAppositivaGiustappostaConValoreConsecutivo",
	"rel app antec giust ipo": "hasClauseType:RelativaAppositivaGiustappostaConValoreIpotetico",
	"rel app antec giust man": "hasClauseType:RelativaAppositivaGiustappostaConValoreDiManiera",
	"rel app antec strum": "hasClauseType:RelativaAppositivaConAntecedenteConValoreStrumentale",
	"rel giust": "hasClauseType:RelativaGiustapposta",
	"rel impl": "hasClauseType:RelativaImplicita",
	"rel impl cons": "hasClauseType:RelativaImplicitaConValoreConsecutivo",
	"rel impl deon": "hasClauseType:RelativaImplicitaDeontica",
	"rel impl fin": "hasClauseType:RelativaImplicitaConValoreFinale",
	"rel impl lim": "hasClauseType:RelativaImplicitaConValoreLimitativo",
	"rel ind": "hasClauseType:RelativaIndipendente",
	"rel ind acond": "hasClauseType:RelativaIndipendenteAcondizionale",
	"rel ind caus": "hasClauseType:RelativaIndipendenteInCostruttoCausale",
	"rel ind comp": "hasClauseType:RelativaIndipendenteInCostruttoComparativo",
	"rel ind ipo": "hasClauseType:RelativaIndipendenteConValoreIpotetico",
	"rel ind mod": "hasClauseType:RelativaIndipendenteConValoreModale",
	"rel ind mod comp ug": "hasClauseType:RelativaIndipendenteInCostruttoComparativoModale",
	"rel ind temp": "hasClauseType:RelativaIndipendenteConValoreTemporale",
	"rel ind temp acond": "hasClauseType:RelativaIndipendenteConValoreTemporaleAcondizionale",
	"rel ind temp caus": "hasClauseType:RelativaIndipendenteConValoreTemporaleCausale",
	"rel ind temp comp ug": "hasClauseType:RelativaIndipendenteInCostruttoComparativoDiUguaglianza",
	"rel pseudo": "hasClauseType:PseudoRelativa",
	"rel pseudo fin": "hasClauseType:PseudoRelativaConValoreFinale",
	"rel pseudo scissa": "hasClauseType:PseudoRelativaScissa",
	"rel pseudo scissa temp": "hasClauseType:PseudoRelativaScissaConValoreTemporale",
	"rel restr antec": "hasClauseType:RelativaRestrittivaConAntecedente",
	"rel restr antec caus": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreCausale",
	"rel restr antec comp disug": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoDiDisuguaglianza",
	"rel restr antec comp mod": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoModale",
	"rel restr antec comp ug": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoComparativoDiUguaglianza",
	"rel restr antec conc cond": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreDiConcessivaCondizionale",
	"rel restr antec conc fatt": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreDiConcessivaFattuale",
	"rel restr antec cons": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreConsecutivo",
	"rel restr antec eccett": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoEccettuativo",
	"rel restr antec fin": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreFinale",
	"rel restr antec ipo": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreIpotetico",
	"rel restr antec lim": "hasClauseType:RelativaRestrittivaConAntecedenteInCostruttoLimitativo",
	"rel restr antec temp": "hasClauseType:RelativaRestrittivaConAntecedenteConValoreTemporale",
	"rip": "hasClauseType:FunzioneDiRipresa",
	"sogg": "hasClauseType:Soggettiva",
	"sogg aci": "hasClauseType:Soggettiva",
	"sogg id": "hasClauseType:Soggettiva",
	"sogg infinitoprep": "hasClauseType:Soggettiva",
	"sogg scissa": "hasClauseType:SoggettivaScissa",
	"sogg soll": "hasClauseType:SoggettivaASollevamento",
	"spec": "hasClauseType:Specificativa",
	"spec aci": "hasClauseType:Specificativa",
	"spec infinitoprep": "hasClauseType:Specificativa",
	"strum": "hasClauseType:Strumentale",
	"subord": "hasClauseType:Subordinata",
	"temp": "hasClauseType:Temporale",
	"temp comp ug": "hasClauseType:TemporaleConValoreComparativo",
	"temp ipo": "hasClauseType:TemporaleConValoreIpotetico",
}