diff --git a/data/examples/2007-ertms.unl.ipynb b/data/examples/2007-ertms.unl.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..afcb4983703b17de36837af68414c75d553e6af9
--- /dev/null
+++ b/data/examples/2007-ertms.unl.ipynb
@@ -0,0 +1,14842 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tempfile\n",
+    "import os\n",
+    "from subprocess import Popen, PIPE, STDOUT\n",
+    "from IPython.core.display import SVG"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def unl2dot(text, path):\n",
+    "    with tempfile.NamedTemporaryFile() as temp:\n",
+    "        out_name = os.path.basename(temp.name)\n",
+    "        out_dir = os.path.dirname(temp.name)\n",
+    "\n",
+    "    with tempfile.NamedTemporaryFile(mode=\"w\") as in_file:\n",
+    "        # Remove CRLF and flush output to avoid java errors\n",
+    "        in_file.write(text.replace(\"\\r\\n\", \"\\n\"))\n",
+    "        in_file.flush()\n",
+    "\n",
+    "        # Run java parser\n",
+    "        cmd = ['java', '-jar', path,\n",
+    "               '--input-file', in_file.name,\n",
+    "               '--output-Dir', out_dir, '--output-file', out_name,\n",
+    "               '--output-type', 'dot']\n",
+    "\n",
+    "        with Popen(cmd, stdout=PIPE, stderr=STDOUT) as p:\n",
+    "            p.wait()\n",
+    "            p.stdout.flush()\n",
+    "            if p.returncode != 0:\n",
+    "                print(\"Error in unl2rdf: \\n\\n\"+p.stdout.read().decode())\n",
+    "                print('UNL;')\n",
+    "                print(text)\n",
+    "\n",
+    "    # generate dot output\n",
+    "    fname = '{}/{}.dot'.format(out_dir, out_name)\n",
+    "    cmd = ['dot', '-Tsvg', fname]\n",
+    "    with Popen(cmd, stdout=PIPE, stderr=PIPE) as p:\n",
+    "        p.wait()\n",
+    "        if p.returncode != 0:\n",
+    "            print(\"Error creating svg: \\n\\n\"+p.stderr.read().decode())\n",
+    "            print('UNL:')\n",
+    "            print(text)\n",
+    "            try:\n",
+    "                with open(fname) as f:\n",
+    "                    print('DOT:')\n",
+    "                    print(f.read())\n",
+    "            except FileNotFoundError:\n",
+    "                pass\n",
+    "        else:\n",
+    "            svg = p.stdout.read().decode()\n",
+    "            os.remove(fname)\n",
+    "            return svg\n",
+    "    return \"\"\n",
+    "\n",
+    "\n",
+    "def displayUnl(unldata) :\n",
+    "# We generate protoSVG because whent there are several sentences, \n",
+    "# a string composed of several concatenated SVG is produced (not a valid SVG).\n",
+    "# We must then split the string to obtain several valid SVG to display.\n",
+    "    protoSvg = unl2dot(unldata, \"unl2rdf-app-1.0-SNAPSHOT-jar-with-dependencies.jar\")\n",
+    "    sep = \"</svg>\\n\"\n",
+    "    svgArray = [x+sep for x in protoSvg.split(sep)]\n",
+    "    svgArray.pop()\n",
+    "    for svg in svgArray :\n",
+    "        display(SVG(svg))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "ERTMS/ETCS Functional Requirements Specification FRS\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "ERTMS/ETCS Functional Requirements Specification FRS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or(etcs,ertms)\n",
+    "mod(specification(icl>description>thing).@maiuscul,etcs)\n",
+    "mod(specification(icl>description>thing).@maiuscul,functional(icl>adj,ant>nonfunctional).@maiuscul)\n",
+    "mod(specification(icl>description>thing).@maiuscul,requirement(icl>duty>thing).@pl.@maiuscul)\n",
+    "mod(frs.@entry,specification(icl>description>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Introduction\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Introduction. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "introduction(icl>section>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "General requirements\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "General requirements. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(requirement(icl>duty>thing).@entry.@pl,general(icl>adj,ant>specific))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Basic functioning\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Basic functioning. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(function(icl>do,equ>operate,agt>thing).@entry,basic(icl>adj,ant>incidental))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Application levels\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Application levels. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry.@pl,application(icl>information,equ>request,agt>thing,obj>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Operation with existing national train control systems\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Operation with existing national train control systems. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(system(icl>group>thing).@pl,national(icl>adj,ant>international))\n",
+    "mod(control(icl>power>thing),train(icl>public_transport>thing))\n",
+    "mod(system(icl>group>thing).@pl,control(icl>power>thing))\n",
+    "obj(operation(icl>business_activity>thing).@entry,system(icl>group>thing).@pl)\n",
+    "aoj(exist(icl>be,aoj>thing,scn>thing).@continue,system(icl>group>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Operational states\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Operational states. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(state(icl>attribute>abstract_thing).@entry.@pl,operational(icl>adj,com>operation))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "National values\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "National values. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(value(icl>property,obj>thing).@entry.@pl,national(icl>adj,ant>international))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Default values for the national values\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Default values for the national values. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(value(icl>property,obj>thing):01.@entry.@pl,default(icl>absence>thing))\n",
+    "mod(value(icl>property,obj>thing):02.@def.@pl,national(icl>adj,ant>international))\n",
+    "pur(value(icl>property,obj>thing):01.@entry.@pl,value(icl>property,obj>thing):02.@def.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Functions\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "function(icl>mathematical_relation>thing).@entry.@pl\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Operational Functions\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Operational Functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl.@maiuscul,operational(icl>adj,com>operation))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "On Board Equipment self Test\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "On Board Equipment self Test. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(test(icl>evaluate>do,agt>volitional_thing,obj>thing,cao>uw,met>thing).@entry.@imperative.@maiuscul,on_board(icl>how,obj>thing))\n",
+    "obj(on_board(icl>how,obj>thing),equipment(icl>instrumentality>thing).@maiuscul)\n",
+    "mod(test(icl>evaluate>do,agt>volitional_thing,obj>thing,cao>uw,met>thing).@entry.@imperative.@maiuscul,self)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train and driver Data Entry\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train and driver Data Entry. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(entry(icl>written_record>thing).@maiuscul,train(icl>public_transport>thing).@entry)\n",
+    "mod(data(icl>collection>thing).@maiuscul,driver(icl>operator>thing,ant>nondriver))\n",
+    "mod(train(icl>public_transport>thing).@entry,data(icl>collection>thing).@maiuscul)\n",
+    "mod(entry(icl>written_record>thing).@maiuscul,data(icl>collection>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Shunting operation\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Shunting operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing).@progress,operation(icl>business_activity>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Partial Supervision\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Partial Supervision. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(supervision(icl>management>thing).@entry.@maiuscul,partial(icl>adj))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Full Supervision operation\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Full Supervision operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(operation(icl>business_activity>thing).@entry,full(icl>adj,ant>empty))\n",
+    "mod(operation(icl>business_activity>thing).@entry,supervision(icl>management>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Isolation of ETCS trainborne equipment\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Isolation of ETCS trainborne equipment. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing),trainborne)\n",
+    "obj(isolation(icl>separation>thing).@entry,equipment(icl>instrumentality>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Compatibility with existing train control and protection systems\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Compatibility with existing train control and protection systems. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(control(icl>power>thing).@entry,train(icl>public_transport>thing))\n",
+    "and:01(system(icl>group>thing).@entry.@pl,control(icl>power>thing).@entry)\n",
+    "mod(control(icl>power>thing).@entry,protection(icl>action,agt>thing,obj>thing,cag>thing))\n",
+    "obj(compatibility(icl>sympathy>thing).@entry,:01.@_hn-scope)\n",
+    "aoj(exist(icl>be,aoj>thing,scn>thing).@continue,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Unfitted Line Operation\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Unfitted Line Operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(operation(icl>business_activity>thing).@entry.@maiuscul,line(icl>formation>thing).@maiuscul)\n",
+    "obj(unfit(icl>change>do,equ>disqualify,rsn>thing,agt>thing,obj>thing).@state,operation(icl>business_activity>thing).@entry.@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Infrastructure Functions\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Infrastructure Functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl.@maiuscul,infrastructure(icl>structure>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "End of movement authority\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "End of movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "agt(end(icl>moment>time,ant>beginning).@entry,authority(icl>abstract_thing,obj>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Supervision of driving into a section of track which could be occupied (On Sight operation)\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Supervision of driving into a section of track which could be occupied (On Sight operation). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(supervision(icl>management>thing).@entry,driving(icl>action>abstract_thing,agt>thing,obj>vehicle))\n",
+    "plt(driving(icl>action>abstract_thing,agt>thing,obj>vehicle),section(icl>writing>thing).@indef)\n",
+    "obj(driving(icl>action>abstract_thing,agt>thing,obj>vehicle),track(icl>line>thing,equ>path))\n",
+    "obj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@past.@ability,track(icl>line>thing,equ>path))\n",
+    "mod:01(operation(icl>business_activity>thing).@entry,sight(icl>visual_percept>thing).@maiuscul)\n",
+    "plc(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@past.@ability,:01.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Trainborne Functions\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Trainborne Functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl.@maiuscul,trainborne)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Dynamic train speed profile calculation\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Dynamic train speed profile calculation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(train(icl>public_transport>thing),dynamic(icl>adj,ant>undynamic))\n",
+    "mod(speed(icl>rate>thing),train(icl>public_transport>thing))\n",
+    "mod(profile(icl>chart>thing),speed(icl>rate>thing))\n",
+    "mod(calculation(icl>procedure>thing).@entry,profile(icl>chart>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Release speed calculation\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Release speed calculation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(speed(icl>rate>thing),release(icl>merchandise>thing))\n",
+    "mod(calculation(icl>procedure>thing).@entry,speed(icl>rate>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train location\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train location. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(location(icl>object>thing).@entry,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Speed calculation and indication\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Speed calculation and indication. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(calculation(icl>procedure>thing).@entry,speed(icl>rate>thing))\n",
+    "mod(indication(icl>communication>thing),speed(icl>rate>thing))\n",
+    "and(indication(icl>communication>thing),calculation(icl>procedure>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Indication displayed on the DMI\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Indication displayed on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry.@past,indication(icl>communication>thing))\n",
+    "plc(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry.@past,on)\n",
+    "obj(on,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Supervision of movement authorities and speed limits\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Supervision of movement authorities and speed limits. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(authority(icl>abstract_thing,obj>uw).@entry.@pl,movement(icl>happening>thing))\n",
+    "and:01(limit(icl>extent>thing).@entry.@pl,authority(icl>abstract_thing,obj>uw).@entry.@pl)\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@entry.@pl,speed(icl>rate>thing))\n",
+    "obj(supervision(icl>management>thing).@entry,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Roll away and reverse movement protection\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Roll away and reverse movement protection. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(:01,roll_away(icl>move>do,plt>uw,plf>uw,agt>thing,obj>thing,plc>uw).@entry.@imperative)\n",
+    "mod:01(protection(icl>action,agt>thing,obj>thing,cag>thing),movement(icl>happening>thing))\n",
+    "obj:01(reverse(icl>change>do,agt>thing,obj>thing).@entry,protection(icl>action,agt>thing,obj>thing,cag>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Recording the ETCS information\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Recording the ETCS information. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(information(icl>message>thing).@def,etcs)\n",
+    "obj(record(icl>write>do,plt>uw,obj>uw).@entry,information(icl>message>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Special Operations\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Special Operations. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(operation(icl>business_activity>thing).@entry.@pl.@maiuscul,special(icl>adj,equ>particular))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Using multiple traction units\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Using multiple traction units. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@entry.@pl,multiple(icl>adj,ant>single))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@entry.@pl,traction(icl>pull>thing))\n",
+    "agt(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@progress,unit(icl>measure>abstract_thing,aoj>uw).@entry.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Using multiple traction units\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Using multiple traction units. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@entry.@pl,multiple(icl>adj,ant>single))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@entry.@pl,traction(icl>pull>thing))\n",
+    "agt(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@progress,unit(icl>measure>abstract_thing,aoj>uw).@entry.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train reversing\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train reversing. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(reverse(icl>change>do,agt>thing,obj>thing).@entry,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Functions required in the event of incidents or other (non ETCS) system failures\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Functions required in the event of incidents or other (non ETCS) system failures. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@past,function(icl>mathematical_relation>thing).@pl)\n",
+    "scn(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@past,event(icl>psychological_feature>thing).@def)\n",
+    "or:02(failure(icl>nonaccomplishment>thing).@entry.@pl,incident(icl>happening>thing).@entry.@pl)\n",
+    "mod(:02.@_hn-scope,other(icl>adj,equ>different))\n",
+    "mod:01(etcs.@entry,non)\n",
+    "mod:02(failure(icl>nonaccomplishment>thing).@entry.@pl,system(icl>group>thing))\n",
+    "obj(other(icl>adj,equ>different),:01.@parenthesis)\n",
+    "obj(event(icl>psychological_feature>thing).@def,:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Passing a stop signal with restricted movement authority\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Passing a stop signal with restricted movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry,stop(icl>stay>thing).@indef)\n",
+    "plc(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry,signal(icl>communication>thing))\n",
+    "mod(signal(icl>communication>thing),with(icl>how,com>possession,obj>thing,mod<thing))\n",
+    "mod(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "obj(with(icl>how,com>possession,obj>thing,mod<thing),authority(icl>abstract_thing,obj>uw))\n",
+    "obj(restrict(icl>limit>do,obj>thing,gol>uw).@state,authority(icl>abstract_thing,obj>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Protection Functions\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Protection Functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl.@maiuscul,protection(icl>action,agt>thing,obj>thing,cag>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Emergency stop to train(s)\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Emergency stop to train(s). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(stop(icl>stay>thing).@entry,emergency(icl>crisis>thing))\n",
+    "pur(stop(icl>stay>thing).@entry,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "shd(train(icl>practice>do,agt>person,obj>person,gol>uw),s.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Route suitability\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Route suitability. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(suitability(icl>quality>thing,ant>unsuitability).@entry,route(icl>line>thing,equ>path))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train trip\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train trip. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trip(icl>journey>thing).@entry,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train Control Centre Functions\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train Control Centre Functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(control(icl>power>thing).@maiuscul,train(icl>public_transport>thing))\n",
+    "mod(center(icl>place,pof>concrete_thing).@maiuscul,control(icl>power>thing).@maiuscul)\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl.@maiuscul,center(icl>place,pof>concrete_thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train identification\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train identification. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(identification(icl>determination>thing,equ>designation).@entry,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Geographical position of the train\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Geographical position of the train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(position(icl>place,aoj>thing,plc>thing).@entry,geographic(icl>adj,com>geography))\n",
+    "aoj(position(icl>place,aoj>thing,plc>thing).@entry,train(icl>public_transport>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Additional Functions\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Additional Functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl.@maiuscul,additional(icl>adj,equ>extra))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Control of pantograph and power supply\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Control of pantograph and power supply. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and:02(supply(icl>indefinite_quantity>thing).@entry,pantograph(icl>mechanical_device>thing).@entry)\n",
+    "mod(supply(icl>indefinite_quantity>thing).@entry,power(icl>quality>thing,ant>powerlessness))\n",
+    "obj(control(icl>power>thing).@entry,:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Air tightness control\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Air tightness control. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(tightness(icl>immovability>thing,ant>looseness),air(icl>travel>abstract_thing,equ>air_travel))\n",
+    "mod(control(icl>power>thing).@entry,tightness(icl>immovability>thing,ant>looseness))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Plain text transmission\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Plain text transmission. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(transmission(icl>sending>thing).@entry,plain(icl>adj,equ>apparent))\n",
+    "mod(transmission(icl>sending>thing).@entry,text(icl>passage>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Fixed text messages\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Fixed text messages. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,text(icl>passage>thing))\n",
+    "mod(message(icl>communication>thing).@entry.@pl,text(icl>passage>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Management of special brakes\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Management of special brakes. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(brake(icl>restraint>thing).@pl,special(icl>adj,equ>particular))\n",
+    "obj(management(icl>action,agt>volitional_thing,obj>thing).@entry,brake(icl>restraint>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Functions primarily related to RBC\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Functions primarily related to RBC. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(relate(icl>think>do,equ>associate,agt>thing,obj>thing).@entry.@past,function(icl>mathematical_relation>thing).@pl)\n",
+    "man(relate(icl>think>do,equ>associate,agt>thing,obj>thing).@entry.@past,primarily(icl>how,equ>mainly))\n",
+    "obj(relate(icl>think>do,equ>associate,agt>thing,obj>thing).@entry.@past,rbc(icl>blood_cell>thing,equ>red_blood_cell))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "Train Integrity\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train Integrity. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(integrity(icl>state>thing).@entry.@maiuscul,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "Train Data to be sent to trackside\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train Data to be sent to trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(data(icl>collection>thing).@entry.@maiuscul,train(icl>public_transport>thing))\n",
+    "obj:01(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing),data(icl>collection>thing).@entry.@maiuscul)\n",
+    "rec:01(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing),trackside)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "Revocation of a Movement Authority\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Revocation of a Movement Authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@indef.@maiuscul,movement(icl>happening>thing).@maiuscul)\n",
+    "obj(revocation(icl>abrogation>thing).@entry,authority(icl>abstract_thing,obj>uw).@indef.@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "Reversing\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Reversing. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "reverse(icl>change>do,agt>thing,obj>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "Handover when passing from one RBC area to another\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Handover when passing from one RBC area to another. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(handover(icl>relinquishment>thing).@entry,pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing))\n",
+    "qua(area(icl>extent>abstract_thing,obj>thing),one(icl>digit>thing))\n",
+    "mod(area(icl>extent>abstract_thing,obj>thing),rbc(icl>blood_cell>thing,equ>red_blood_cell))\n",
+    "plf(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),area(icl>extent>abstract_thing,obj>thing))\n",
+    "plt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),another(icl>adj,equ>another))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "Failures and Fall-back Procedures\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Failures and Fall-back Procedures. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(procedure(icl>activity>thing).@pl.@maiuscul,failure(icl>nonaccomplishment>thing).@entry.@pl)\n",
+    "mod(back(icl>organ,pof>body,mod>living_thing),fall(icl>slip>thing,equ>spill).@maiuscul)\n",
+    "mod(failure(icl>nonaccomplishment>thing).@entry.@pl,back(icl>organ,pof>body,mod>living_thing))\n",
+    "mod(procedure(icl>activity>thing).@pl.@maiuscul,back(icl>organ,pof>body,mod>living_thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "Interruption in transmission\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Interruption in transmission. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(interruption(icl>delay>thing,equ>break).@entry,transmission(icl>sending>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "Transmission Failures\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Transmission Failures. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(failure(icl>nonaccomplishment>thing).@entry.@pl.@maiuscul,transmission(icl>sending>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "On board equipment failures\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "On board equipment failures. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(failure(icl>nonaccomplishment>thing).@pl,equipment(icl>instrumentality>thing))\n",
+    "obj(on_board(icl>how,obj>thing).@entry,failure(icl>nonaccomplishment>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Fault indications to the driver\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Fault indications to the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(indication(icl>communication>thing).@entry.@pl,fault(icl>responsibility>thing))\n",
+    "obj(indication(icl>communication>thing).@entry.@pl,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Driver-Machine Interface\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Driver-Machine Interface. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(machine(icl>device>thing).@maiuscul,driver(icl>operator>thing,ant>nondriver))\n",
+    "mod(interface(icl>surface>thing).@entry.@maiuscul,machine(icl>device>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Training\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Training. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "training(icl>activity>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Reliability, Availability, Maintenability, Safety (RAMS)\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Reliability, Availability, Maintenability, Safety (RAMS). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(availability(icl>convenience>thing,equ>handiness,ant>unavailability).@maiuscul,reliability(icl>responsibility>thing,equ>dependability,ant>unreliability).@entry)\n",
+    "and(safety(icl>condition>thing,ant>danger).@maiuscul,availability(icl>convenience>thing,equ>handiness,ant>unavailability).@maiuscul)\n",
+    "shd(availability(icl>convenience>thing,equ>handiness,ant>unavailability).@maiuscul,maintenability.@vocative)\n",
+    "cnt(safety(icl>condition>thing,ant>danger).@maiuscul,ram(icl>volatile_storage>thing,equ>random-access_memory).@pl.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Environmental Specification\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Environmental Specification. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(specification(icl>description>thing).@entry.@maiuscul,environmental(icl>adj,com>ecology))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Glossary\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Glossary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "glossary(icl>wordbook>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Other technical functions\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Other technical functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl,other(icl>adj,equ>different))\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl,technical(icl>adj,ant>nontechnical))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "This document defines the functional requirements for ERTMS/ETCS (EUROPEAN RAIL TRAFFIC MANAGEMENT SYSTEM / EUROPEAN TRAIN CONTROL SYSTEM). The document primarily defines the operational requirements and therefore contains only a few technical terms. For consistency reasons, all functional requirements not implemented in the SRS 2.3.0 have been removed from this version.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This document defines the functional requirements for ERTMS/ETCS (EUROPEAN RAIL TRAFFIC MANAGEMENT SYSTEM / EUROPEAN TRAIN CONTROL SYSTEM). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(document(icl>writing>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present,document(icl>writing>thing))\n",
+    "mod(requirement(icl>duty>thing).@def.@pl,functional(icl>adj,ant>nonfunctional))\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present,requirement(icl>duty>thing).@def.@pl)\n",
+    "or(etcs,ertms)\n",
+    "pur(requirement(icl>duty>thing).@def.@pl,etcs)\n",
+    "mod:01(management(icl>action,agt>volitional_thing,obj>thing),traffic(icl>collection>thing))\n",
+    "mod(:03.@_hn-scope,management(icl>action,agt>volitional_thing,obj>thing))\n",
+    "or:03(european(icl>inhabitant>person).@entry,system(icl>group>thing):01.@entry)\n",
+    "mod:01(control(icl>power>thing),train(icl>public_transport>thing))\n",
+    "mod:01(system(icl>group>thing):02,control(icl>power>thing))\n",
+    "agt:02(rail(icl>complain>do,rsn>thing,agt>volitional_thing).@entry.@present,:01.@entry.@parenthesis)\n",
+    "rsn:02(rail(icl>complain>do,rsn>thing,agt>volitional_thing).@entry.@present,:01.@entry.@parenthesis)\n",
+    "shd(etcs,:02)\n",
+    "mod(train(icl>public_transport>thing),:03.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The document primarily defines the operational requirements and therefore contains only a few technical terms. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present,document(icl>writing>thing).@def)\n",
+    "man(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present,primarily(icl>how,equ>mainly))\n",
+    "and(:01,define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present)\n",
+    "mod(requirement(icl>duty>thing).@def.@pl,operational(icl>adj,com>operation))\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present,requirement(icl>duty>thing).@def.@pl)\n",
+    "man:01(contain(icl>be,equ>comprise,obj>abstract_thing,aoj>information,pur>abstract_thing).@entry.@present,therefore(icl>how))\n",
+    "man:01(term(icl>word>thing,mod>thing).@pl,only(icl>how,equ>recently))\n",
+    "qua:01(term(icl>word>thing,mod>thing).@pl,a_few(icl>adj,equ>some,qua<thing))\n",
+    "mod:01(term(icl>word>thing,mod>thing).@pl,technical(icl>adj,ant>nontechnical))\n",
+    "obj:01(contain(icl>be,equ>comprise,obj>abstract_thing,aoj>information,pur>abstract_thing).@entry.@present,term(icl>word>thing,mod>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "For consistency reasons, all functional requirements not implemented in the SRS 2.3.0 have been removed from this version. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt:01(reason(icl>persuade>do,agt>thing,gol>uw,rec>person).@entry.@present,consistency(icl>uniformity>thing,ant>inconsistency))\n",
+    "qua:02(requirement(icl>duty>thing).@pl,all(icl>quantity,ant>some,per>thing))\n",
+    "mod:02(requirement(icl>duty>thing).@pl,functional(icl>adj,ant>nonfunctional))\n",
+    "agt:02(implement(icl>employ>do,agt>thing,obj>thing).@past.@not,requirement(icl>duty>thing).@pl)\n",
+    "plc(remove(icl>dismiss>do,plf>thing,agt>volitional_thing,obj>person).@entry.@present.@complete,srs.@def)\n",
+    "obj(remove(icl>dismiss>do,plf>thing,agt>volitional_thing,obj>person).@entry.@present.@complete,\"2.3\".@topic)\n",
+    "mod(\"2.3\".@topic,\".0\")\n",
+    "mod(version(icl>interpretation>abstract_thing,agt>thing,obj>uw),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "plf(remove(icl>dismiss>do,plf>thing,agt>volitional_thing,obj>person).@entry.@present.@complete,version(icl>interpretation>abstract_thing,agt>thing,obj>uw))\n",
+    "and(implement(icl>employ>do,agt>thing,obj>thing).@past.@not,:01)\n",
+    "rsn(remove(icl>dismiss>do,plf>thing,agt>volitional_thing,obj>person).@entry.@present.@complete,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "In the requirements of this document:\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "(M) = Mandatory:The requirement shall be respected in every ETCS application. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(m(icl>metric_linear_unit>thing,equ>meter).@entry.@parenthesis,=)\n",
+    "mod(=,mandatory(icl>adj,equ>compulsory).@maiuscul)\n",
+    "obj(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,requirement(icl>duty>thing).@def.@topic)\n",
+    "cnt(mandatory(icl>adj,equ>compulsory).@maiuscul,respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise)\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw),every(icl>quantity,per>thing))\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw),etcs)\n",
+    "scn(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,application(icl>information,equ>request,agt>thing,obj>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The applicable requirements stated in ETCS SRS and lower level mandatory specifications shall be respected. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(requirement(icl>duty>thing).@def.@pl.@topic,applicable(icl>adj))\n",
+    "obj(state(icl>define>do,agt>thing,obj>thing).@state,requirement(icl>duty>thing).@def.@pl.@topic)\n",
+    "obj(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@entry.@present.@promise,requirement(icl>duty>thing).@def.@pl.@topic)\n",
+    "mod(:01.@_hn-scope,etcs)\n",
+    "and:01(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry,srs.@entry)\n",
+    "mod(specification(icl>description>thing).@pl,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry)\n",
+    "mod(specification(icl>description>thing).@pl,mandatory(icl>adj,equ>compulsory))\n",
+    "plc(state(icl>define>do,agt>thing,obj>thing).@state,specification(icl>description>thing).@pl)\n",
+    "man(low_degree_of(icl>adj,aoj>thing),more(icl>how))\n",
+    "aoj(low_degree_of(icl>adj,aoj>thing),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "(O) = Optional:It is not mandatory to implement this function in every ETCS application. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(=,o.@parenthesis)\n",
+    "agt(implement(icl>employ>do,agt>thing,obj>thing).@entry.@present,=)\n",
+    "mod(=,optional(icl>adj,ant>obligatory).@maiuscul)\n",
+    "mod(function(icl>mathematical_relation>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "obj(implement(icl>employ>do,agt>thing,obj>thing).@entry.@present,function(icl>mathematical_relation>thing))\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw),every(icl>quantity,per>thing))\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw),etcs)\n",
+    "scn(function(icl>mathematical_relation>thing),application(icl>information,equ>request,agt>thing,obj>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If implemented, the applicable requirements stated in ETCS SRS and lower level mandatory specifications shall be respected. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "con(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,implement(icl>employ>do,agt>thing,obj>thing).@entry)\n",
+    "mod(requirement(icl>duty>thing).@def.@pl.@topic,applicable(icl>adj))\n",
+    "obj(state(icl>define>do,agt>thing,obj>thing).@state,requirement(icl>duty>thing).@def.@pl.@topic)\n",
+    "obj(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,requirement(icl>duty>thing).@def.@pl.@topic)\n",
+    "mod(:01.@_hn-scope,etcs)\n",
+    "and:01(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry,srs.@entry)\n",
+    "mod(specification(icl>description>thing).@pl,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry)\n",
+    "mod(specification(icl>description>thing).@pl,mandatory(icl>adj,equ>compulsory))\n",
+    "plc(state(icl>define>do,agt>thing,obj>thing).@state,specification(icl>description>thing).@pl)\n",
+    "man(low_degree_of(icl>adj,aoj>thing),more(icl>how))\n",
+    "aoj(low_degree_of(icl>adj,aoj>thing),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Note that the CCS TSI may define specific conditions, where implementation of O functions may be required for safety reasons.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(tsi.@def,ccs)\n",
+    "aoj(suppose(icl>modal>be,obj>uw,aoj>thing),tsi.@def)\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing),tsi.@def)\n",
+    "obj(note(icl>mention>do,agt>person,obj>uw).@entry.@imperative,suppose(icl>modal>be,obj>uw,aoj>thing))\n",
+    "obj(suppose(icl>modal>be,obj>uw,aoj>thing),define(icl>characterize>be,obj>uw,aoj>thing))\n",
+    "mod(condition(icl>state>abstract_thing,aoj>thing).@pl,specific(icl>adj,equ>particular,ant>general))\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing),condition(icl>state>abstract_thing,aoj>thing).@pl)\n",
+    "plc:02(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present.@grant,where(icl>how,plc<uw))\n",
+    "obj:02(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present.@grant,implementation(icl>enforcement>thing,equ>execution).@topic)\n",
+    "shd:01(o.@maiuscul,function(icl>mathematical_relation>thing).@entry.@pl)\n",
+    "mod:02(reason(icl>rational_motive>thing).@pl,safety(icl>condition>thing,ant>danger))\n",
+    "pur:02(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present.@grant,reason(icl>rational_motive>thing).@pl)\n",
+    "obj:02(implementation(icl>enforcement>thing,equ>execution).@topic,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In the requirements of this document:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(document(icl>record>do,agt>thing,obj>thing).@entry.@imperative,requirement(icl>duty>thing).@def.@pl)\n",
+    "obj(requirement(icl>duty>thing).@def.@pl,this(icl>thing,equ>it,equ>that))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "ETCS shall provide the driver with information to allow him to drive the train safely.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "ETCS shall provide the driver with information to allow him to drive the train safely. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(provide(icl>supply>do,obj>thing,ben>thing).@entry.@present.@promise,etcs)\n",
+    "obj(provide(icl>supply>do,obj>thing,ben>thing).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "ben(provide(icl>supply>do,obj>thing,ben>thing).@entry.@present.@promise,information(icl>message>thing))\n",
+    "agt:02(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@entry,he(icl>person))\n",
+    "obj:02(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@entry,train(icl>public_transport>thing).@def)\n",
+    "man:02(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@entry,safely(icl>how))\n",
+    "pur(provide(icl>supply>do,obj>thing,ben>thing).@entry.@present.@promise,:01)\n",
+    "obj:01(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "ETCS shall be able to supervise train and shunting movements.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "ETCS shall be able to supervise train and shunting movements. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(ability(icl>modal>be,obj>uw,aoj>thing).@entry.@promise,etcs)\n",
+    "agt(supervise(icl>control>do,agt>volitional_thing,obj>thing),etcs)\n",
+    "and(:01,ability(icl>modal>be,obj>uw,aoj>thing).@entry.@promise)\n",
+    "obj(ability(icl>modal>be,obj>uw,aoj>thing).@entry.@promise,supervise(icl>control>do,agt>volitional_thing,obj>thing))\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing),train(icl>public_transport>thing))\n",
+    "obj:01(shunt(icl>transfer>do,agt>thing,obj>thing).@entry,movement(icl>happening>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If the supervision is performed by a RBC it shall be possible to prevent movements of a traction unit in its area if not authorised by the RBC.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the supervision is performed by a RBC it shall be possible to prevent movements of a traction unit in its area if not authorised by the RBC. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(perform(icl>do,agt>thing,obj>thing).@entry.@present,supervision(icl>management>thing).@def.@topic)\n",
+    "con(possible(icl>adj,ant>impossible).@present.@promise,perform(icl>do,agt>thing,obj>thing).@entry.@present)\n",
+    "agt(perform(icl>do,agt>thing,obj>thing).@entry.@present,rbc(icl>blood_cell>thing,equ>red_blood_cell):01.@indef)\n",
+    "obj:01(prevent(icl>forestall>do,agt>thing,obj>thing).@entry,movement(icl>happening>thing).@pl)\n",
+    "mod:01(unit(icl>measure>abstract_thing,aoj>uw).@indef,traction(icl>pull>thing))\n",
+    "obj:01(movement(icl>happening>thing).@pl,unit(icl>measure>abstract_thing,aoj>uw).@indef)\n",
+    "pos:01(area(icl>extent>abstract_thing,obj>thing),it(icl>living_thing))\n",
+    "plc:01(unit(icl>measure>abstract_thing,aoj>uw).@indef,area(icl>extent>abstract_thing,obj>thing))\n",
+    "agt:02(authorize(icl>permit>do,agt>volitional_thing,obj>thing,ben>thing).@entry.@not,rbc(icl>blood_cell>thing,equ>red_blood_cell):02.@def)\n",
+    "aoj(possible(icl>adj,ant>impossible).@present.@promise,:01)\n",
+    "con:01(area(icl>extent>abstract_thing,obj>thing),:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "ETCS is required to be functional to a maximum train speed of 500 km/h.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "ETCS is required to be functional to a maximum train speed of 500 km/h. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj:01(functional(icl>adj,ant>nonfunctional),etcs.@entry.@topic)\n",
+    "mod:01(train(icl>public_transport>thing),maximum(icl>extremum>thing,ant>minimum))\n",
+    "mod:01(speed(icl>rate>thing).@indef,train(icl>public_transport>thing))\n",
+    "to:01(functional(icl>adj,ant>nonfunctional),speed(icl>rate>thing).@indef)\n",
+    "qua:01(km slash h.@pl,500)\n",
+    "obj:01(speed(icl>rate>thing).@indef,km slash h.@pl)\n",
+    "obj(require(icl>request>do,agt>person,obj>uw,rec>thing).@entry.@present,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The following definitions shall apply for the ETCS application levels:\n",
+    "\t\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Level 0: ETCS active for limited train control function; trackside not fitted with any train control system or fitted with a train control system for which no STM is available onboard. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry,0)\n",
+    "agt:01(control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing):01.@entry.@present,etcs)\n",
+    "mod:01(etcs,active(icl>adj))\n",
+    "mod:01(train(icl>public_transport>thing):01,limited(icl>adj,ant>unlimited))\n",
+    "plt:01(active(icl>adj),train(icl>public_transport>thing):01)\n",
+    "obj:01(control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing):01.@entry.@present,function(icl>mathematical_relation>thing))\n",
+    "aoj(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing):01.@not.@state,trackside)\n",
+    "agt(control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing):02.@present,trackside)\n",
+    "mod(train(icl>public_transport>thing):02,any(icl>adj))\n",
+    "gol(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing):01.@not.@state,train(icl>public_transport>thing):02)\n",
+    "or(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing):02.@past,control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing):02.@present)\n",
+    "obj(control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing):02.@present,system(icl>group>thing):01)\n",
+    "mod(0,fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing):02.@past)\n",
+    "gol(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing):02.@past,train(icl>public_transport>thing):03.@indef)\n",
+    "mod(system(icl>group>thing):02,control(icl>power>thing))\n",
+    "obj(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing):02.@past,system(icl>group>thing):02)\n",
+    "mod(stm,system(icl>group>thing):02)\n",
+    "pur(onboard.@present,which)\n",
+    "mod(stm,no(icl>quantity,qua<thing))\n",
+    "aoj(onboard.@present,stm)\n",
+    "mod(onboard.@present,available(icl>adj,ant>unavailable))\n",
+    "or(control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing):02.@present,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Level 1: Basic track to train information via intermittent transmission media, e.g. balises. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry,1)\n",
+    "mod(track(icl>line>thing,equ>path),basic(icl>adj,ant>incidental).@maiuscul)\n",
+    "cnt(1,track(icl>line>thing,equ>path))\n",
+    "pur(track(icl>line>thing,equ>path),train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry,information(icl>message>thing))\n",
+    "mod(medium(icl>instrumentality>thing).@pl,intermittent(icl>adj))\n",
+    "mod(medium(icl>instrumentality>thing).@pl,transmission(icl>sending>thing))\n",
+    "via(information(icl>message>thing),medium(icl>instrumentality>thing).@pl)\n",
+    "man(balises,\"e.g.\"(icl>how,equ>for_example))\n",
+    "obj(train(icl>practice>do,agt>person,obj>person,gol>uw),balises)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This information can be supported by infill, transmitted via balise, loop or radio. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(information(icl>message>thing).@topic,this(icl>determiner>adj,mod<concrete_thing))\n",
+    "obj(support(icl>help>do,agt>thing,obj>person,met>thing,scn>uw).@entry.@present.@ability,information(icl>message>thing).@topic)\n",
+    "or(balise,infill)\n",
+    "obj(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@state,via)\n",
+    "mod(balise,via)\n",
+    "or(loop(icl>fastener>thing,equ>cringle),balise)\n",
+    "or(radio(icl>media>abstract_thing),loop(icl>fastener>thing,equ>cringle))\n",
+    "agt(support(icl>help>do,agt>thing,obj>person,met>thing,scn>uw).@entry.@present.@ability,radio(icl>media>abstract_thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Level 2: Basic track to train and train to track information via continuous transmission media, i.e. radio. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry,2)\n",
+    "mod(:01.@_hn-scope,basic(icl>adj,ant>incidental).@maiuscul)\n",
+    "and:01(train(icl>public_transport>thing).@entry,track(icl>line>thing,equ>path).@entry)\n",
+    "pur:01(track(icl>line>thing,equ>path).@entry,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "pur:01(train(icl>public_transport>thing).@entry,track(icl>mark>do,agt>thing,obj>thing))\n",
+    "obj:01(track(icl>mark>do,agt>thing,obj>thing),information(icl>message>thing))\n",
+    "mod:01(medium(icl>instrumentality>thing).@pl,continuous(icl>adj,ant>discontinuous))\n",
+    "mod:01(medium(icl>instrumentality>thing).@pl,transmission(icl>sending>thing))\n",
+    "via:01(information(icl>message>thing),medium(icl>instrumentality>thing).@pl)\n",
+    "man:01(radio(icl>media>abstract_thing),\"i.e.\"(icl>how))\n",
+    "cnt:01(medium(icl>instrumentality>thing).@pl,radio(icl>media>abstract_thing))\n",
+    "cnt(2,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train detection is provided by trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(detection(icl>perception>thing).@def.@topic,train(icl>public_transport>thing))\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present,detection(icl>perception>thing).@def.@topic)\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present,trackside)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Level 3: Same as level 2 except that train integrity is provided by onboard and therefore trackside. train detection is optional. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):01.@entry,3)\n",
+    "mod(3,same(icl>adj,ant>other).@maiuscul)\n",
+    "man(same(icl>adj,ant>other).@maiuscul,as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw),level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02,2)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02,except(icl>how,obj>thing))\n",
+    "mod(integrity(icl>state>thing).@topic,train(icl>public_transport>thing):01)\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@present,integrity(icl>state>thing).@topic)\n",
+    "and(optional(icl>adj,ant>obligatory).@present,provide(icl>equip>do,cob>thing,obj>thing).@present)\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@present,onboard)\n",
+    "man(provide(icl>equip>do,cob>thing,obj>thing).@present,therefore(icl>how).@parenth)\n",
+    "mod(train(icl>public_transport>thing):02,trackside)\n",
+    "mod(detection(icl>perception>thing),train(icl>public_transport>thing):02)\n",
+    "aoj(optional(icl>adj,ant>obligatory).@present,detection(icl>perception>thing))\n",
+    "obj(except(icl>how,obj>thing),optional(icl>adj,ant>obligatory).@present)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Level STM (Specific Transmission Module): Track to train information provided by national system. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(stm,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw))\n",
+    "agt(track(icl>mark>do,agt>thing,obj>thing).@entry.@present.@maiuscul,stm)\n",
+    "mod:01(module(icl>component>thing).@entry.@maiuscul,specific(icl>adj,equ>particular,ant>general).@maiuscul)\n",
+    "mod:01(module(icl>component>thing).@entry.@maiuscul,transmission(icl>sending>thing).@maiuscul)\n",
+    "pur(track(icl>mark>do,agt>thing,obj>thing).@entry.@present.@maiuscul,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "obj(train(icl>practice>do,agt>person,obj>person,gol>uw),information(icl>message>thing))\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@state,information(icl>message>thing))\n",
+    "mod(system(icl>group>thing),national(icl>adj,ant>international))\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@state,system(icl>group>thing))\n",
+    "cnt(stm,:01.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Onboard functions provided by national system (STM) in co-operation with onboard ETCS.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@pl,onboard:01)\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@state,function(icl>mathematical_relation>thing).@entry.@pl)\n",
+    "mod(system(icl>group>thing),national(icl>adj,ant>international))\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@state,system(icl>group>thing))\n",
+    "nam(system(icl>group>thing),stm.@parenthesis)\n",
+    "scn(system(icl>group>thing),cooperation(icl>group_action>thing,ant>competition))\n",
+    "mod(etcs,onboard:02)\n",
+    "obj(cooperation(icl>group_action>thing,ant>competition),etcs)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The following definitions shall apply for the ETCS application levels:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(definition(icl>explanation>thing).@def.@pl,following(icl>adj,ant>leading))\n",
+    "agt(apply(icl>do,equ>ask,plt>thing,agt>person,pur>uw).@entry.@present.@promise,definition(icl>explanation>thing).@def.@pl)\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw),etcs)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@pl,application(icl>information,equ>request,agt>thing,obj>uw))\n",
+    "pur(apply(icl>do,equ>ask,plt>thing,agt>person,pur>uw).@entry.@present.@promise,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to implement one or more of the ETCS application levels on a line.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to implement one or more of the ETCS application levels on a line. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,implement(icl>employ>do,agt>thing,obj>thing))\n",
+    "or(more(icl>how),one(icl>unit>thing))\n",
+    "obj(implement(icl>employ>do,agt>thing,obj>thing),more(icl>how))\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw),etcs)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@pl,application(icl>information,equ>request,agt>thing,obj>uw))\n",
+    "per(one(icl>unit>thing),level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@pl)\n",
+    "plc(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@pl,on(icl>how,com>surface,obj>concrete_thing,plc<uw))\n",
+    "obj(on(icl>how,com>surface,obj>concrete_thing,plc<uw),line(icl>formation>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Trains equipped for ERTMS/ETCS application level 3 shall be able to run on lines equipped with ERTMS/ETCS application level 3, 2, 1 and 0, trains equipped for ERTMS/ETCS application level 2 shall be able to run on lines equipped with ERTMS/ETCS application level 2, 1 and 0 and trains equipped for ERTMS/ETCS application level 1 shall be able to run on lines equipped with ERTMS/ETCS application level 1 and 0.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Trains equipped for ERTMS/ETCS application level 3 shall be able to run on lines equipped with ERTMS/ETCS application level 3, 2, 1 and 0, trains equipped for ERTMS/ETCS application level 2 shall be able to run on lines equipped with ERTMS/ETCS application level 2, 1 and 0 and trains equipped for ERTMS/ETCS application level 1 shall be able to run on lines equipped with ERTMS/ETCS application level 1 and 0. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:02(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):01.@state,train(icl>public_transport>thing):01.@pl)\n",
+    "aoj:02(promise(icl>modal>be,obj>uw,aoj>thing):01.@entry,train(icl>public_transport>thing):01.@pl)\n",
+    "obj:02(promise(icl>modal>be,obj>uw,aoj>thing):01.@entry,train(icl>public_transport>thing):01.@pl)\n",
+    "aoj(run(icl>go>do,plt>uw,plf>uw,agt>thing):01.@entry.@ability,train(icl>public_transport>thing):01.@pl)\n",
+    "mod:02(application(icl>information,equ>request,agt>thing,obj>uw):01,ertms:01)\n",
+    "mod:02(application(icl>information,equ>request,agt>thing,obj>uw):01,etcs:01)\n",
+    "mod:02(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):01,application(icl>information,equ>request,agt>thing,obj>uw):01)\n",
+    "pur:02(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):01.@state,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):01)\n",
+    "mod:02(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):01,3:01)\n",
+    "man:02(promise(icl>modal>be,obj>uw,aoj>thing):02,promise(icl>modal>be,obj>uw,aoj>thing):01.@entry)\n",
+    "plt(run(icl>go>do,plt>uw,plf>uw,agt>thing):01.@entry.@ability,on(icl>how,plt<uw,obj>concrete_thing):01)\n",
+    "obj(on(icl>how,plt<uw,obj>concrete_thing):01,line(icl>formation>thing):01.@pl)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):02.@state,line(icl>formation>thing):01.@pl)\n",
+    "ins(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):02.@state,ertms:02)\n",
+    "mod:02(application(icl>information,equ>request,agt>thing,obj>uw):02,etcs:02)\n",
+    "mod:02(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02,application(icl>information,equ>request,agt>thing,obj>uw):02)\n",
+    "aoj:02(promise(icl>modal>be,obj>uw,aoj>thing):02,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02)\n",
+    "obj:02(promise(icl>modal>be,obj>uw,aoj>thing):02,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02)\n",
+    "aoj(run(icl>go>do,plt>uw,plf>uw,agt>thing):02.@ability,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02)\n",
+    "and:02(2:01,3:02)\n",
+    "and:02(1:01,2:01)\n",
+    "mod:02(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02,1:01)\n",
+    "obj(and(icl>how,obj>uw,and<uw):01,1:01)\n",
+    "qua:01(train(icl>public_transport>thing):02.@pl,0:01)\n",
+    "obj:01(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):03.@entry.@state,train(icl>public_transport>thing):02.@pl)\n",
+    "mod:01(application(icl>information,equ>request,agt>thing,obj>uw):03,ertms:03)\n",
+    "mod:01(application(icl>information,equ>request,agt>thing,obj>uw):03,etcs:03)\n",
+    "mod:01(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):03,application(icl>information,equ>request,agt>thing,obj>uw):03)\n",
+    "pur:01(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):03.@entry.@state,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):03)\n",
+    "mod:01(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):03,2:02)\n",
+    "plt(run(icl>go>do,plt>uw,plf>uw,agt>thing):02.@ability,on(icl>how,plt<uw,obj>concrete_thing):02)\n",
+    "obj(on(icl>how,plt<uw,obj>concrete_thing):02,line(icl>formation>thing):02.@pl)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):04.@state,line(icl>formation>thing):02.@pl)\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw):04,ertms:04)\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw):04,etcs:04)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):04,application(icl>information,equ>request,agt>thing,obj>uw):04)\n",
+    "ins(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):04.@state,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):04)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):04,2:03)\n",
+    "qua:03(train(icl>public_transport>thing):03.@pl,1:02.@entry)\n",
+    "and(0:02,and(icl>how,com>single_value,obj>quantity,and<quantity):01)\n",
+    "obj(and(icl>how,obj>uw,and<uw):02,0:02)\n",
+    "obj:03(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):05.@state,train(icl>public_transport>thing):03.@pl)\n",
+    "aoj(run(icl>go>do,plt>uw,plf>uw,agt>thing):03.@present.@ability.@promise,train(icl>public_transport>thing):03.@pl)\n",
+    "mod:03(application(icl>information,equ>request,agt>thing,obj>uw):05,ertms:05)\n",
+    "mod:03(application(icl>information,equ>request,agt>thing,obj>uw):05,etcs:05)\n",
+    "mod:03(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):05,application(icl>information,equ>request,agt>thing,obj>uw):05)\n",
+    "pur:03(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):05.@state,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):05)\n",
+    "mod:03(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):05,1:03)\n",
+    "plt(run(icl>go>do,plt>uw,plf>uw,agt>thing):03.@present.@ability.@promise,on(icl>how,plt<uw,obj>concrete_thing):03)\n",
+    "obj(on(icl>how,plt<uw,obj>concrete_thing):03,line(icl>formation>thing):03.@pl)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):06.@state,line(icl>formation>thing):03.@pl)\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw):06,ertms:06)\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw):06,etcs:06)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):06,application(icl>information,equ>request,agt>thing,obj>uw):06)\n",
+    "ins(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):06.@state,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):06)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):06,1:04)\n",
+    "obj(and(icl>how,com>single_value,obj>quantity,and<quantity):02,1:04)\n",
+    "and(\"0.\",and(icl>how,com>single_value,obj>quantity,and<quantity):02)\n",
+    "cnt:02(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02,:01)\n",
+    "man:02(promise(icl>modal>be,obj>uw,aoj>thing):02,:03)\n",
+    "obj(and(icl>how,com>single_value,obj>quantity,and<quantity):01,:03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The current application level shall be indicated on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The current application level shall be indicated on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@topic,current(icl>adj,ant>noncurrent))\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@topic,application(icl>information,equ>request,agt>thing,obj>uw))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@topic)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall acknowledge the level transitions, if requested from trackside. If the driver does not acknowledge after the transition the brake shall be applied. If the driver acknowledges afterwards, the brake can be released\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall acknowledge the level transitions, if requested from trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(acknowledge(icl>communicate>do,equ>receipt,agt>volitional_thing,obj>information).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(transition(icl>change_of_state>thing,equ>passage).@def.@pl,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw))\n",
+    "obj(acknowledge(icl>communicate>do,equ>receipt,agt>volitional_thing,obj>information).@entry.@present.@promise,transition(icl>change_of_state>thing,equ>passage).@def.@pl)\n",
+    "frm:01(request(icl>communicate>do,agt>volitional_thing,obj>thing).@entry,trackside)\n",
+    "con(transition(icl>change_of_state>thing,equ>passage).@def.@pl,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the driver does not acknowledge after the transition the brake shall be applied. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt:01(acknowledge(icl>admit>do,agt>volitional_thing,obj>thing).@entry.@not.@present,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "con:01(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@present.@promise,acknowledge(icl>admit>do,agt>volitional_thing,obj>thing).@entry.@not.@present)\n",
+    "tim:01(acknowledge(icl>admit>do,agt>volitional_thing,obj>thing).@entry.@not.@present,after(icl>how,tim<uw,obj>uw))\n",
+    "obj:01(after(icl>how,tim<uw,obj>uw),transition(icl>change_of_state>thing,equ>passage).@def)\n",
+    "obj:01(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@present.@promise,brake(icl>restraint>thing).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the driver acknowledges afterwards, the brake can be released. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt:01(acknowledge(icl>admit>do,agt>volitional_thing,obj>thing).@entry.@present,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "con:01(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@present.@ability,acknowledge(icl>admit>do,agt>volitional_thing,obj>thing).@entry.@present)\n",
+    "tim:01(acknowledge(icl>admit>do,agt>volitional_thing,obj>thing).@entry.@present,afterwards(icl>how,equ>subsequently,com>subsequent))\n",
+    "obj:01(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@present.@ability,brake(icl>restraint>thing).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "ETCS shall be compatible with existing national systems listed in the CCS TSI such that it does not interfere with the national systems and is not interfered with by the national systems.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "ETCS shall be compatible with existing national systems listed in the CCS TSI such that it does not interfere with the national systems and is not interfered with by the national systems. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(compatible(icl>adj,ant>incompatible).@entry.@present.@promise,etcs)\n",
+    "mod(system(icl>group>thing):01.@pl,national(icl>adj,ant>international):01)\n",
+    "obj(compatible(icl>adj,ant>incompatible).@entry.@present.@promise,system(icl>group>thing):01.@pl)\n",
+    "aoj(exist(icl>be,aoj>thing,scn>thing).@continue,system(icl>group>thing):01.@pl)\n",
+    "obj(list(icl>enumerate>do,agt>thing,obj>thing).@state,system(icl>group>thing):01.@pl)\n",
+    "mod(tsi.@def,ccs)\n",
+    "plc(list(icl>enumerate>do,agt>thing,obj>thing).@state,tsi.@def)\n",
+    "mod:01(system(icl>group>thing):02.@entry.@def.@pl,national(icl>adj,ant>international):02)\n",
+    "met:03(interfere(icl>impede>be,obj>thing,aoj>uw):02.@entry.@not.@present,with(icl>how,obj>abstract_thing,met<uw))\n",
+    "mod:03(system(icl>group>thing):03.@def.@pl,national(icl>adj,ant>international):03)\n",
+    "aoj:03(interfere(icl>impede>be,obj>thing,aoj>uw):02.@entry.@not.@present,system(icl>group>thing):03.@def.@pl)\n",
+    "aoj:02(interfere(icl>impede>be,obj>thing,aoj>uw):01.@entry.@not.@present,:01)\n",
+    "obj:02(interfere(icl>impede>be,obj>thing,aoj>uw):01.@entry.@not.@present,:01)\n",
+    "mod(system(icl>group>thing):01.@pl,:02)\n",
+    "and(:03,:02)\n",
+    "obj(such(icl>adj,equ>such),:03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS trainborne equipment shall be capable of supervising the following operational states:\n",
+    "\t\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Full Supervision operation, Partial Supervision operation, Staff Responsible operation, On Sight operation, Unfitted Line operation, Train Trip operation, Post Trip operation, National operation (STM), Tandem operation, Multiple operation, Shunting operation, Stand By operation, Reversing operation.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:05(operation(icl>business_activity>thing):01,full(icl>adj,ant>empty))\n",
+    "mod:05(operation(icl>business_activity>thing):01,supervision(icl>management>thing):01.@maiuscul)\n",
+    "agt:05(unfit(icl>change>do,equ>disqualify,rsn>thing,agt>thing,obj>thing).@entry.@past.@maiuscul,operation(icl>business_activity>thing):01)\n",
+    "mod:03(operation(icl>business_activity>thing):02.@entry,partial(icl>adj).@maiuscul)\n",
+    "mod:03(operation(icl>business_activity>thing):02.@entry,supervision(icl>management>thing):02.@maiuscul)\n",
+    "mod:04(operation(icl>business_activity>thing):03.@entry,responsible(icl>adj,ant>irresponsible).@maiuscul)\n",
+    "obj:04(responsible(icl>adj,ant>irresponsible).@maiuscul,staff(icl>force>thing).@maiuscul)\n",
+    "mod:05(operation(icl>business_activity>thing):04,sight(icl>visual_percept>thing).@maiuscul)\n",
+    "plc:05(unfit(icl>change>do,equ>disqualify,rsn>thing,agt>thing,obj>thing).@entry.@past.@maiuscul,operation(icl>business_activity>thing):04)\n",
+    "mod:05(operation(icl>business_activity>thing):05,line(icl>formation>thing).@maiuscul)\n",
+    "obj:05(unfit(icl>change>do,equ>disqualify,rsn>thing,agt>thing,obj>thing).@entry.@past.@maiuscul,operation(icl>business_activity>thing):05)\n",
+    "mod:06(trip(icl>journey>thing):01.@maiuscul,train(icl>public_transport>thing).@maiuscul)\n",
+    "mod:06(operation(icl>business_activity>thing):06.@entry,trip(icl>journey>thing):01.@maiuscul)\n",
+    "mod:07(trip(icl>journey>thing):02.@maiuscul,post(icl>position>thing).@maiuscul)\n",
+    "mod:07(operation(icl>business_activity>thing):07.@entry,trip(icl>journey>thing):02.@maiuscul)\n",
+    "mod(operation(icl>business_activity>thing):08,national(icl>adj,ant>international).@maiuscul)\n",
+    "fictit(stand_by(icl>be,obj>uw,aoj>person).@entry.@imperative.@maiuscul,operation(icl>business_activity>thing):08)\n",
+    "cnt(operation(icl>business_activity>thing):08,stm.@parenthesis)\n",
+    "mod:08(operation(icl>business_activity>thing):09.@entry,tandem(icl>bicycle>thing,equ>bicycle-built-for-two).@maiuscul)\n",
+    "mod:09(operation(icl>business_activity>thing):10.@entry,multiple(icl>adj,ant>single).@maiuscul)\n",
+    "obj(stand_by(icl>be,obj>uw,aoj>person).@entry.@imperative.@maiuscul,operation(icl>business_activity>thing):12)\n",
+    "cnt:05(operation(icl>business_activity>thing):01,:03)\n",
+    "cnt:03(operation(icl>business_activity>thing):02.@entry,:04)\n",
+    "mod(stand_by(icl>be,obj>uw,aoj>person).@entry.@imperative.@maiuscul,:05)\n",
+    "cnt:05(operation(icl>business_activity>thing):05,:06)\n",
+    "cnt:06(operation(icl>business_activity>thing):06.@entry,:07)\n",
+    "cnt(operation(icl>business_activity>thing):08,:08)\n",
+    "cnt:08(operation(icl>business_activity>thing):09.@entry,:09)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall be capable of supervising the following operational states:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "aoj(capable(icl>adj).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "obj(capable(icl>adj).@entry.@present.@promise,supervise(icl>control>do,agt>volitional_thing,obj>thing))\n",
+    "mod(state(icl>attribute>abstract_thing).@def.@pl,following(icl>adj,ant>leading))\n",
+    "mod(state(icl>attribute>abstract_thing).@def.@pl,operational(icl>adj,com>operation))\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing),state(icl>attribute>abstract_thing).@def.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Any transition which occurs while the train is moving shall in principle occur automatically.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Any transition which occurs while the train is moving shall in principle occur automatically. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(transition(icl>change_of_state>thing,equ>passage),any(icl>adj))\n",
+    "obj(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw):01.@present,transition(icl>change_of_state>thing,equ>passage))\n",
+    "obj(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw):02.@entry.@present.@promise,transition(icl>change_of_state>thing,equ>passage))\n",
+    "dur(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw):01.@present,while(icl>how,equ>whilst,tim<uw,obj>uw))\n",
+    "obj:01(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing).@entry.@present.@progress,train(icl>public_transport>thing).@def)\n",
+    "scn(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw):02.@entry.@present.@promise,principle(icl>generalization>thing))\n",
+    "man(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw):02.@entry.@present.@promise,automatically(icl>how,com>automatic))\n",
+    "obj(while(icl>how,equ>whilst,tim<uw,obj>uw),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Transitions which occur while the train is stationary, shall be initiated automatically or manually as appropriate.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Transitions which occur while the train is stationary, shall be initiated automatically or manually as appropriate. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw).@present,transition(icl>change_of_state>thing,equ>passage).@entry.@pl)\n",
+    "dur(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw).@present,while(icl>how,equ>whilst,tim<uw,obj>uw))\n",
+    "aoj:01(stationary(icl>adj).@entry.@present,train(icl>public_transport>thing).@def)\n",
+    "and:01(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@entry.@present.@promise,stationary(icl>adj).@entry.@present)\n",
+    "or(manually(icl>how,com>manual),automatically(icl>how,com>automatic))\n",
+    "man(stationary(icl>adj).@entry.@present,manually(icl>how,com>manual))\n",
+    "man:01(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@entry.@present.@promise,as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj:01(as(icl>how,com>degree,obj>uw,man<uw),appropriate(icl>adj,ant>inappropriate))\n",
+    "obj(while(icl>how,equ>whilst,tim<uw,obj>uw),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If, as a result of an automatic transition, except for transitions to and from National Operation (STM), the responsibility for the driver increases, the ETCS shall seek an acknowledgement from the driver, whether the train is stationary or not.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If, as a result of an automatic transition, except for transitions to and from National Operation (STM), the responsibility for the driver increases, the ETCS shall seek an acknowledgement from the driver, whether the train is stationary or not. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "con(promise(icl>modal>be,obj>uw,aoj>thing).@entry,if(icl>how,obj>uw,con<uw))\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw),result(icl>phenomenon>thing,equ>consequence).@indef)\n",
+    "mod(transition(icl>change_of_state>thing,equ>passage):01.@indef,automatic(icl>adj,ant>manual))\n",
+    "obj(result(icl>phenomenon>thing,equ>consequence).@indef,transition(icl>change_of_state>thing,equ>passage):01.@indef)\n",
+    "pur:01(except(icl>exclude>do,src>uw,agt>thing,obj>thing).@entry,transition(icl>change_of_state>thing,equ>passage):02.@pl)\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,to(icl>how,com>content,obj>thing))\n",
+    "mod(:02.@_hn-scope,national(icl>adj,ant>international).@maiuscul)\n",
+    "and:02(responsibility(icl>social_control>thing,equ>duty).@entry.@def,operation(icl>business_activity>thing).@entry.@maiuscul)\n",
+    "nam:02(operation(icl>business_activity>thing).@entry.@maiuscul,stm.@parenthesis)\n",
+    "and:02(etcs.@entry.@def,responsibility(icl>social_control>thing,equ>duty).@entry.@def)\n",
+    "mod:02(increase(icl>indefinite_quantity>thing,equ>addition).@pl,driver(icl>operator>thing,ant>nondriver):01.@def)\n",
+    "obj:02(responsibility(icl>social_control>thing,equ>duty).@entry.@def,increase(icl>indefinite_quantity>thing,equ>addition).@pl)\n",
+    "frm(to(icl>how,com>content,obj>thing),)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,seek(icl>request>do,agt>person,obj>thing,cag>person))\n",
+    "obj(seek(icl>request>do,agt>person,obj>thing,cag>person),acknowledgement(icl>message>thing,equ>acknowledgment).@indef)\n",
+    "cag(seek(icl>request>do,agt>person,obj>thing,cag>person),driver(icl>operator>thing,ant>nondriver):02.@def)\n",
+    "plc(seek(icl>request>do,agt>person,obj>thing,cag>person),train(icl>public_transport>thing).@def)\n",
+    "aoj(stationary(icl>adj).@present,train(icl>public_transport>thing).@def)\n",
+    "or(not(icl>how,obj<uw),stationary(icl>adj).@present)\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw),:01)\n",
+    "obj(to(icl>how,com>content,obj>thing),:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "For transitions to and from National Operation (STM) the ETCS shall request, an acknowledgement by the driver.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "For transitions to and from National Operation (STM) the ETCS shall request, an acknowledgement by the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "pur(promise(icl>modal>be,obj>uw,aoj>thing).@entry,transition(icl>change_of_state>thing,equ>passage).@pl)\n",
+    "mod(transition(icl>change_of_state>thing,equ>passage).@pl,to(icl>how,com>content,obj>thing))\n",
+    "mod(operation(icl>business_activity>thing).@maiuscul,national(icl>adj,ant>international).@maiuscul)\n",
+    "obj(to(icl>how,com>content,obj>thing),operation(icl>business_activity>thing).@maiuscul)\n",
+    "nam(operation(icl>business_activity>thing).@maiuscul,stm.@parenthesis)\n",
+    "frm(to(icl>how,com>content,obj>thing),)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "agt(request(icl>communicate>do,agt>volitional_thing,obj>thing),etcs.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,request(icl>communicate>do,agt>volitional_thing,obj>thing))\n",
+    "cnt(promise(icl>modal>be,obj>uw,aoj>thing).@entry,acknowledgement(icl>message>thing,equ>acknowledgment).@indef)\n",
+    "met(acknowledgement(icl>message>thing,equ>acknowledgment).@indef,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "In case the transition has to be acknowledged and the driver fails to acknowledge as required, the ETCS shall initiate a brake application\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In case the transition has to be acknowledged and the driver fails to acknowledge as required, the ETCS shall initiate a brake application. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "scn(obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry,case(icl>happening>thing))\n",
+    "obj:01(acknowledge(icl>communicate>do,equ>receipt,agt>volitional_thing,obj>information).@entry,transition(icl>change_of_state>thing,equ>passage).@def.@topic)\n",
+    "and(:02,obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "obj:02(fail(icl>disappoint>occur,cob>thing,obj>thing).@entry.@present,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "man:03(acknowledge(icl>admit>do,agt>volitional_thing,obj>thing).@entry,as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj:03(as(icl>how,com>degree,obj>uw,man<uw),require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing))\n",
+    "agt:04(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@entry.@present.@promise,etcs.@def)\n",
+    "mod:04(application(icl>information,equ>request,agt>thing,obj>uw).@indef,brake(icl>restraint>thing))\n",
+    "obj:04(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@entry.@present.@promise,application(icl>information,equ>request,agt>thing,obj>uw).@indef)\n",
+    "obj(obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "and(:04,:02)\n",
+    "cob:02(fail(icl>disappoint>occur,cob>thing,obj>thing).@entry.@present,:03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "During the transition period between two operational states (including two different national operations) the supervision provided shall at least ensure the same protection provided by the least restrictive state.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "During the transition period between two operational states (including two different national operations) the supervision provided shall at least ensure the same protection provided by the least restrictive state. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(period(icl>fundamental_quantity>thing,equ>time_period).@def,transition(icl>change_of_state>thing,equ>passage))\n",
+    "dur(promise(icl>modal>be,obj>uw,aoj>thing).@entry,period(icl>fundamental_quantity>thing,equ>time_period).@def)\n",
+    "plc(period(icl>fundamental_quantity>thing,equ>time_period).@def,between(icl>how,obj>thing,plc<uw))\n",
+    "qua(state(icl>attribute>abstract_thing):01.@pl,two(icl>digit>thing):01)\n",
+    "mod(state(icl>attribute>abstract_thing):01.@pl,operational(icl>adj,com>operation))\n",
+    "obj(between(icl>how,obj>thing,plc<uw),state(icl>attribute>abstract_thing):01.@pl)\n",
+    "qua:01(operation(icl>business_activity>thing).@entry.@pl,two(icl>digit>thing):02)\n",
+    "mod:01(operation(icl>business_activity>thing).@entry.@pl,different(icl>adj,ant>same))\n",
+    "mod:01(operation(icl>business_activity>thing).@entry.@pl,national(icl>adj,ant>international))\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing):01.@state,supervision(icl>management>thing).@def)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,supervision(icl>management>thing).@def)\n",
+    "aoj(ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing),supervision(icl>management>thing).@def)\n",
+    "man(ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing),at_least(icl>how))\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing))\n",
+    "mod(protection(icl>action,agt>thing,obj>thing,cag>thing).@def,same(icl>adj,ant>other))\n",
+    "obj(ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing),protection(icl>action,agt>thing,obj>thing,cag>thing).@def)\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing):02.@state,protection(icl>action,agt>thing,obj>thing,cag>thing).@def)\n",
+    "man(restrictive(icl>adj,ant>unrestrictive),least(icl>how))\n",
+    "mod(state(icl>attribute>abstract_thing):02.@def,restrictive(icl>adj,ant>unrestrictive))\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing):02.@state,state(icl>attribute>abstract_thing):02.@def)\n",
+    "obj:02(include(icl>contain>be,obj>thing,aoj>thing).@entry,:01.@entry.@parenthesis)\n",
+    "shd(state(icl>attribute>abstract_thing):01.@pl,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If an ETCS equipped train passes a level transition to a line fitted with more than one level, the onboard shall switch to the highest level, according to the priority given by trackside, for which it is equipped.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If an ETCS equipped train passes a level transition to a line fitted with more than one level, the onboard shall switch to the highest level, according to the priority given by trackside, for which it is equipped. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):01.@state,etcs)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):01.@state,train(icl>public_transport>thing).@indef)\n",
+    "agt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present,train(icl>public_transport>thing).@indef)\n",
+    "con(switch(icl>switch_over>occur,src>uw,obj>thing,gol>uw).@present.@promise,pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present)\n",
+    "mod(transition(icl>change_of_state>thing,equ>passage).@indef,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):01)\n",
+    "plc(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present,transition(icl>change_of_state>thing,equ>passage).@indef)\n",
+    "man(transition(icl>change_of_state>thing,equ>passage).@indef,line(icl>formation>thing).@indef)\n",
+    "obj(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing).@state,line(icl>formation>thing).@indef)\n",
+    "gol(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing).@state,more(icl>how))\n",
+    "qua(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02,one(icl>digit>thing))\n",
+    "bas(more(icl>how),level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02)\n",
+    "obj(switch(icl>switch_over>occur,src>uw,obj>thing,gol>uw).@present.@promise,onboard.@def)\n",
+    "gol(switch(icl>switch_over>occur,src>uw,obj>thing,gol>uw).@present.@promise,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):03.@def)\n",
+    "aoj(high_degree_of(icl>adj,aoj>thing),level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):03.@def)\n",
+    "src(switch(icl>switch_over>occur,src>uw,obj>thing,gol>uw).@present.@promise,according_to(icl>how,src>uw,obj>uw))\n",
+    "obj(according_to(icl>how,src>uw,obj>uw),priority(icl>high_status>thing,equ>precedence).@def)\n",
+    "obj(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@state,priority(icl>high_status>thing,equ>precedence).@def)\n",
+    "agt(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@state,trackside)\n",
+    "cob(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):02.@present,trackside)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):02.@present,it(icl>thing).@topic)\n",
+    "man(high_degree_of(icl>adj,aoj>thing),most(icl>how))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If an ETCS equipped train passes a level transition to one or more levels for which it is not equipped, ETCS shall initiate a brake application.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If an ETCS equipped train passes a level transition to one or more levels for which it is not equipped, ETCS shall initiate a brake application. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man:01(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):01.@state,etcs:01)\n",
+    "obj:01(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):01.@state,train(icl>public_transport>thing).@indef)\n",
+    "agt:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present,train(icl>public_transport>thing).@indef)\n",
+    "con:01(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@present.@promise,pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present)\n",
+    "mod:01(transition(icl>change_of_state>thing,equ>passage).@indef,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):01)\n",
+    "or:01(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02.@pl,transition(icl>change_of_state>thing,equ>passage).@indef)\n",
+    "man:01(transition(icl>change_of_state>thing,equ>passage).@indef,one(icl>digit>thing))\n",
+    "qua:01(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02.@pl,more(icl>quantity,ant>less,qua<thing,bas>uw))\n",
+    "plc:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02.@pl)\n",
+    "cob(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):02.@entry.@not.@present,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw):02.@pl)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing):02.@entry.@not.@present,it(icl>thing).@topic)\n",
+    "agt:01(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@present.@promise,etcs:02)\n",
+    "mod:01(application(icl>information,equ>request,agt>thing,obj>uw).@indef,brake(icl>restraint>thing))\n",
+    "obj:01(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@present.@promise,application(icl>information,equ>request,agt>thing,obj>uw).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The current operational status shall be indicated to the driver on the DMI\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The current operational status shall be indicated to the driver on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(status(icl>state>thing).@def.@topic,current(icl>adj,ant>noncurrent))\n",
+    "mod(status(icl>state>thing).@def.@topic,operational(icl>adj,com>operation))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,status(icl>state>thing).@def.@topic)\n",
+    "agt(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "plc(driver(icl>operator>thing,ant>nondriver).@def,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS on-board shall be capable of receiving National values from the trackside to adapt to National requirements\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS on-board shall be capable of receiving National values from the trackside to adapt to National requirements. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "aoj(capable(icl>adj),etcs.@def)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on-board)\n",
+    "mod:01(value(icl>property,obj>thing).@pl,national(icl>adj,ant>international):01.@maiuscul)\n",
+    "obj:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,value(icl>property,obj>thing).@pl)\n",
+    "src:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,trackside.@def)\n",
+    "mod:02(requirement(icl>duty>thing).@pl,national(icl>adj,ant>international):02.@maiuscul)\n",
+    "cob:02(adapt(icl>change>occur,equ>conform,cob>thing,obj>thing).@entry,requirement(icl>duty>thing).@pl)\n",
+    "obj(capable(icl>adj),:01)\n",
+    "pur:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "National values shall be applicable to a defined area\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "National values shall be applicable to a defined area. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(value(icl>property,obj>thing).@pl,national(icl>adj,ant>international))\n",
+    "aoj(applicable(icl>adj).@entry.@present.@promise,value(icl>property,obj>thing).@pl)\n",
+    "obj(applicable(icl>adj).@entry.@present.@promise,area(icl>extent>abstract_thing,obj>thing).@indef)\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@state,area(icl>extent>abstract_thing,obj>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Once received onboard the national values shall remain valid even if the onboard equipment is switched off\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Once received onboard the national values shall remain valid even if the onboard equipment is switched off. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(receive(icl>acquire>do,src>thing,obj>thing).@state,once(icl>how))\n",
+    "agt(receive(icl>acquire>do,src>thing,obj>thing).@state,onboard:01)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,onboard:01)\n",
+    "aoj(remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing),onboard:01)\n",
+    "mod(value(icl>property,obj>thing).@def.@pl,national(icl>adj,ant>international))\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,value(icl>property,obj>thing).@def.@pl)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing))\n",
+    "obj(remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing),valid(icl>adj,ant>invalid))\n",
+    "con(remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing),even(icl>how))\n",
+    "mod:01(equipment(icl>instrumentality>thing).@def.@topic,onboard:02)\n",
+    "obj:01(switch_off(icl>turn_off>do,agt>thing,obj>functional_thing).@entry.@present,equipment(icl>instrumentality>thing).@def.@topic)\n",
+    "obj(remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If the on-board has no valid national values for the current location, default values shall be used by the onboard equipment.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Default values shall be harmonised values, permanently stored in all ERTMS/ETCS on board equipment\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Default values shall be harmonised values, permanently stored in all ERTMS/ETCS on board equipment. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(harmonise(icl>adjust>do,cob>thing,agt>volitional_thing,obj>thing).@present.@promise,default(icl>absence>thing))\n",
+    "mod(value(icl>property,obj>thing):02.@entry.@pl,default(icl>absence>thing))\n",
+    "obj(harmonise(icl>adjust>do,cob>thing,agt>volitional_thing,obj>thing).@present.@promise,value(icl>property,obj>thing):01.@pl.@topic)\n",
+    "obj(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@state,value(icl>property,obj>thing):02.@entry.@pl)\n",
+    "man(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@state,permanently(icl>how,ant>temporarily,com>permanent))\n",
+    "qua:01(ertms.@entry,all(icl>quantity,ant>some,per>thing))\n",
+    "or:01(etcs.@entry,ertms.@entry)\n",
+    "mod(ertms.@entry,on_board(icl>how,obj>thing))\n",
+    "obj(on_board(icl>how,obj>thing),equipment(icl>instrumentality>thing))\n",
+    "plc(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@state,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "At Start Up, the on board equipment shall perform an automatic self-test.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "At Start Up, the on board equipment shall perform an automatic self-test. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(promise(icl>modal>be,obj>uw,aoj>thing).@entry,start(icl>beginning>thing).@maiuscul)\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,up(icl>how,com>height).@maiuscul)\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on board)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,equipment(icl>instrumentality>thing).@def)\n",
+    "agt(perform(icl>do,agt>thing,obj>thing),equipment(icl>instrumentality>thing).@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,perform(icl>do,agt>thing,obj>thing))\n",
+    "mod(self-test.@indef,automatic(icl>adj,ant>manual))\n",
+    "obj(perform(icl>do,agt>thing,obj>thing),self-test.@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The test shall require no action on the part of the driver.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The test shall require no action on the part of the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present.@promise,test(icl>mental_measurement>thing).@def)\n",
+    "mod(action(icl>process,equ>influence,cob>thing,obj>thing),no(icl>quantity,qua<thing))\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present.@promise,action(icl>process,equ>influence,cob>thing,obj>thing))\n",
+    "plc(action(icl>process,equ>influence,cob>thing,obj>thing),part(icl>region>abstract_thing,pof>area).@def)\n",
+    "obj(part(icl>region>abstract_thing,pof>area).@def,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The DMI shall indicate the result of the self-test.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The DMI shall indicate the result of the self-test. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,result(icl>phenomenon>thing,equ>consequence).@def)\n",
+    "obj(result(icl>phenomenon>thing,equ>consequence).@def,self-test.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train data shall be entered before the on-board ETCS equipment allows train movement.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train data shall be entered before the on-board ETCS equipment allows train movement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@topic,train(icl>public_transport>thing):01)\n",
+    "obj(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@promise,data(icl>collection>thing).@topic)\n",
+    "tim(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@promise,before(icl>how,equ>earlier,tim<uw,obj>uw))\n",
+    "mod:01(equipment(icl>instrumentality>thing).@def,on-board)\n",
+    "mod:01(equipment(icl>instrumentality>thing).@def,etcs)\n",
+    "agt:01(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry.@present,equipment(icl>instrumentality>thing).@def)\n",
+    "ben:01(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry.@present,train(icl>public_transport>thing):02)\n",
+    "obj:01(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry.@present,movement(icl>happening>thing))\n",
+    "obj(before(icl>how,equ>earlier,tim<uw,obj>uw),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall be able to select Train Data Entry on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall be able to select Train Data Entry on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present.@ability.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(data(icl>collection>thing).@maiuscul,train(icl>public_transport>thing).@maiuscul)\n",
+    "mod(entry(icl>written_record>thing).@maiuscul,data(icl>collection>thing).@maiuscul)\n",
+    "obj(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present.@ability.@promise,entry(icl>written_record>thing).@maiuscul)\n",
+    "plc(entry(icl>written_record>thing).@maiuscul,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Entering or overwriting data manually by the driver shall be possible but only when stationary.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Entering or overwriting data manually by the driver shall be possible but only when stationary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or:01(overwrite(icl>write>do,agt>thing,obj>thing).@entry,enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry)\n",
+    "aoj(possible(icl>adj,ant>impossible),overwrite(icl>write>do,agt>thing,obj>thing).@entry)\n",
+    "obj:01(overwrite(icl>write>do,agt>thing,obj>thing).@entry,data(icl>collection>thing))\n",
+    "man(:01.@_hn-scope,manually(icl>how,com>manual))\n",
+    "met(promise(icl>modal>be,obj>uw,aoj>thing).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(but(icl>how,equ>however,obj>uw,and<uw),possible(icl>adj,ant>impossible))\n",
+    "and(only(icl>adj,equ>lone),but(icl>how,equ>however,obj>uw,and<uw))\n",
+    "con(possible(icl>adj,ant>impossible),when(icl>how,com>condition,obj>uw,con<uw))\n",
+    "obj(when(icl>how,com>condition,obj>uw,con<uw),stationary(icl>adj))\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01.@_hn-scope)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train data may be entered automatically from a railway management system or from train memory.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train data may be entered automatically from a railway management system or from train memory. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@topic,train(icl>public_transport>thing):01)\n",
+    "obj(enter(icl>put>do,plt>thing,plf>thing,agt>volitional_thing,obj>thing).@entry.@present.@grant,data(icl>collection>thing).@topic)\n",
+    "man(enter(icl>put>do,plt>thing,plf>thing,agt>volitional_thing,obj>thing).@entry.@present.@grant,automatically(icl>how,com>automatic))\n",
+    "mod:01(management(icl>action,agt>volitional_thing,obj>thing),railway(icl>line>thing))\n",
+    "mod:01(system(icl>group>thing).@entry.@indef,management(icl>action,agt>volitional_thing,obj>thing))\n",
+    "or:01(memory(icl>basic_cognitive_process>thing).@entry,system(icl>group>thing).@entry.@indef)\n",
+    "mod(system(icl>group>thing).@entry.@indef,train(icl>public_transport>thing):02)\n",
+    "plf(enter(icl>put>do,plt>thing,plf>thing,agt>volitional_thing,obj>thing).@entry.@present.@grant,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall be able to consult train data when the train is stationary or moving.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall be able to consult train data when the train is stationary or moving. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(consult(icl>ask>do,agt>person,cao>thing,cag>person).@entry.@present.@ability.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(data(icl>collection>thing),train(icl>public_transport>thing):01)\n",
+    "cag(consult(icl>ask>do,agt>person,cao>thing,cag>person).@entry.@present.@ability.@promise,data(icl>collection>thing))\n",
+    "tim(consult(icl>ask>do,agt>person,cao>thing,cag>person).@entry.@present.@ability.@promise,train(icl>public_transport>thing):02.@def)\n",
+    "aoj(stationary(icl>adj).@present,train(icl>public_transport>thing):02.@def)\n",
+    "or(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing),stationary(icl>adj).@present)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Current train data shall be stored (except at transition to shunting) in the ETCS equipment until the traction unit is not operative.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Current train data shall be stored (except at transition to shunting) in the ETCS equipment until the traction unit is not operative. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@topic,current(icl>adj,ant>noncurrent))\n",
+    "mod(data(icl>collection>thing).@topic,train(icl>public_transport>thing))\n",
+    "obj(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@promise,data(icl>collection>thing).@topic)\n",
+    "man:01(transition(icl>change_of_state>thing,equ>passage).@entry,shunt(icl>transfer>do,agt>thing,obj>thing))\n",
+    "mod(equipment(icl>instrumentality>thing).@def,etcs)\n",
+    "plc(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@def,traction(icl>pull>thing))\n",
+    "tmt(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@promise,unit(icl>measure>abstract_thing,aoj>uw).@def)\n",
+    "aoj(operative(icl>adj,ant>inoperative).@not.@present,unit(icl>measure>abstract_thing,aoj>uw).@def)\n",
+    "tim:02(except(icl>exclude>do,src>uw,agt>thing,obj>thing).@entry,:01.@entry.@parenthesis)\n",
+    "shd(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@promise,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Stored train data shall be offered to the driver to be confirmed when Data Entry starts.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Stored train data shall be offered to the driver to be confirmed when Data Entry starts. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing):01,train(icl>public_transport>thing))\n",
+    "obj(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@state,data(icl>collection>thing):01)\n",
+    "aoj(offer(icl>make_available>be,obj>thing,aoj>thing,ben>thing).@entry.@present.@promise,data(icl>collection>thing):01)\n",
+    "ben(offer(icl>make_available>be,obj>thing,aoj>thing,ben>thing).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod:02(entry(icl>written_record>thing).@maiuscul,data(icl>collection>thing):02.@maiuscul)\n",
+    "agt:02(start(icl>begin>do,src>uw,agt>thing,obj>uw).@entry.@present,entry(icl>written_record>thing).@maiuscul)\n",
+    "obj(offer(icl>make_available>be,obj>thing,aoj>thing,ben>thing).@entry.@present.@promise,:01)\n",
+    "tim:01(confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The system for Train Data Entry shall provide for the input of other data required by STMs connected to ETCS. This may require additional items, not required for ETCS, to be entered.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The system for Train Data Entry shall provide for the input of other data required by STMs connected to ETCS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,system(icl>group>thing).@def)\n",
+    "mod(data(icl>collection>thing):01.@maiuscul,train(icl>public_transport>thing).@maiuscul)\n",
+    "mod(entry(icl>written_record>thing).@maiuscul,data(icl>collection>thing):01.@maiuscul)\n",
+    "pur(system(icl>group>thing).@def,entry(icl>written_record>thing).@maiuscul)\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,input(icl>signal>thing,equ>input_signal).@def)\n",
+    "mod(data(icl>collection>thing):02,other(icl>adj,equ>different))\n",
+    "obj(input(icl>signal>thing,equ>input_signal).@def,data(icl>collection>thing):02)\n",
+    "mod(data(icl>collection>thing):02,required(icl>adj,agt>thing,obj>thing,gol>thing).@state)\n",
+    "agt(required(icl>adj,agt>thing,obj>thing,gol>thing).@state,stms)\n",
+    "obj(connect(icl>do,equ>tie,cob>concrete_thing,agt>thing,obj>concrete_thing).@state,stms)\n",
+    "cob(connect(icl>do,equ>tie,cob>concrete_thing,agt>thing,obj>concrete_thing).@state,etcs)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This may require additional items, not required for ETCS, to be entered. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present.@suppose,this(icl>thing,equ>it,equ>that))\n",
+    "mod:01(item(icl>part>thing).@pl,additional(icl>adj,equ>extra))\n",
+    "obj:01(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry,item(icl>part>thing).@pl)\n",
+    "mod:01(item(icl>part>thing).@pl,required(icl>adj,agt>thing,obj>thing,gol>thing).@not.@state)\n",
+    "pur:01(required(icl>adj,agt>thing,obj>thing,gol>thing).@not.@state,etcs)\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present.@suppose,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The entry of driver identification and the selection of the language shall be possible.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The entry of driver identification and the selection of the language shall be possible. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,entry(icl>written_record>thing).@def)\n",
+    "mod(:01.@_hn-scope,driver(icl>operator>thing,ant>nondriver))\n",
+    "and:01(selection(icl>action,agt>thing,obj>thing).@entry.@def,identification(icl>determination>thing,equ>designation).@entry)\n",
+    "obj:01(selection(icl>action,agt>thing,obj>thing).@entry.@def,language(icl>communication>thing).@def)\n",
+    "obj(entry(icl>written_record>thing).@def,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The change of driver identification during a journey or a Train Running Number shall be possible\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The change of driver identification during a journey or a Train Running Number shall be possible. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,change(icl>difference>abstract_thing).@def)\n",
+    "mod(identification(icl>determination>thing,equ>designation),driver(icl>operator>thing,ant>nondriver))\n",
+    "obj(change(icl>difference>abstract_thing).@def,identification(icl>determination>thing,equ>designation))\n",
+    "or:01(number(icl>abstract_thing,icl>quantity,obj>thing).@entry.@indef.@maiuscul,journey(icl>travel>thing).@entry.@indef)\n",
+    "mod(:01.@_hn-scope,train(icl>public_transport>thing).@maiuscul)\n",
+    "mod:01(number(icl>abstract_thing,icl>quantity,obj>thing).@entry.@indef.@maiuscul,running(icl>adj,equ>running).@maiuscul)\n",
+    "dur(identification(icl>determination>thing,equ>designation),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Following successful completion of Train Data Entry, the driver shall be able to perform shunting movements or train movements.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Following successful completion of Train Data Entry, the driver shall be able to perform shunting movements or train movements. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(completion(icl>maneuver>thing),successful(icl>adj,ant>unsuccessful))\n",
+    "agt(follow(icl>move>do,equ>go_after,agt>volitional_thing,obj>volitional_thing).@progress,completion(icl>maneuver>thing))\n",
+    "aoj(perform(icl>icl>work>do,agt>person,man>how).@entry.@present.@ability.@promise,completion(icl>maneuver>thing))\n",
+    "mod(data(icl>collection>thing).@maiuscul,train(icl>public_transport>thing):01.@maiuscul)\n",
+    "mod(entry(icl>written_record>thing).@maiuscul,data(icl>collection>thing).@maiuscul)\n",
+    "obj(completion(icl>maneuver>thing),entry(icl>written_record>thing).@maiuscul)\n",
+    "cnt(entry(icl>written_record>thing).@maiuscul,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "man(perform(icl>icl>work>do,agt>person,man>how).@entry.@present.@ability.@promise,shunt(icl>transfer>do,agt>thing,obj>thing))\n",
+    "or:02(movement(icl>happening>thing):02.@entry.@pl,movement(icl>happening>thing):01.@entry.@pl)\n",
+    "mod(:02.@_hn-scope,train(icl>public_transport>thing):02)\n",
+    "obj(shunt(icl>transfer>do,agt>thing,obj>thing),:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The following data may be entered manually by the driver or from train memory:\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Driver identification, Train identification (train number) STM ready for use, Data required for brake calculation, Maximum train speed, Train length, Status of air tight system, Type of electric power accepted, Data additional required for STM (if any), International train category, Train gauge, Maximum axle load of the train with a resolution of 0,5 t.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(0.@entry,driver(icl>operator>thing,ant>nondriver))\n",
+    "fictit(0.@entry,identification(icl>determination>thing,equ>designation):01)\n",
+    "fictit(0.@entry,train(icl>public_transport>thing):01.@maiuscul)\n",
+    "fictit(0.@entry,identification(icl>determination>thing,equ>designation):02)\n",
+    "mod:02(number(icl>abstract_thing,icl>quantity,obj>thing).@entry,train(icl>public_transport>thing):02)\n",
+    "nam(number(icl>abstract_thing,icl>quantity,obj>thing).@entry,stm:01)\n",
+    "obj:01(ready(icl>adj,ant>unready).@entry,use(icl>activity>thing))\n",
+    "aoj:03(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):01.@past,data(icl>collection>thing):01.@maiuscul)\n",
+    "obj:03(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@state,require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):01.@past)\n",
+    "mod:01(calculation(icl>procedure>thing),brake(icl>restraint>thing))\n",
+    "man:01(use(icl>activity>thing),calculation(icl>procedure>thing))\n",
+    "mod(train(icl>public_transport>thing):03,maximum(icl>extremum>thing,ant>minimum):01.@maiuscul)\n",
+    "mod(speed(icl>rate>thing),train(icl>public_transport>thing):03)\n",
+    "fictit(0.@entry,speed(icl>rate>thing))\n",
+    "mod:03(length(icl>fundamental_quantity>thing),train(icl>public_transport>thing):04.@maiuscul)\n",
+    "obj:03(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):01.@past,length(icl>fundamental_quantity>thing))\n",
+    "aoj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,status(icl>state>thing).@maiuscul)\n",
+    "mod(system(icl>group>thing),air(icl>travel>abstract_thing,equ>air_travel))\n",
+    "mod(system(icl>group>thing),tight(icl>adj,ant>loose))\n",
+    "obj(status(icl>state>thing).@maiuscul,system(icl>group>thing))\n",
+    "agt(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,type(icl>abstract_thing).@maiuscul)\n",
+    "mod:03(power(icl>quality>thing,ant>powerlessness).@entry,electric(icl>adj,com>electricity))\n",
+    "aoj:03(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@state,power(icl>quality>thing,ant>powerlessness).@entry)\n",
+    "mod:03(data(icl>collection>thing):02.@maiuscul,additional(icl>adj,equ>extra))\n",
+    "cnt:03(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):01.@past,data(icl>collection>thing):02.@maiuscul)\n",
+    "fictit(0.@entry,require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past)\n",
+    "pur(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,stm:02)\n",
+    "con(0.@entry,any(icl>adj).@parenthesis)\n",
+    "mod(category(icl>collection>thing,equ>class),international(icl>adj,ant>national).@maiuscul)\n",
+    "mod(category(icl>collection>thing,equ>class),train(icl>public_transport>thing):05)\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,category(icl>collection>thing,equ>class))\n",
+    "mod(gauge(icl>measuring_instrument>thing),train(icl>public_transport>thing):06.@maiuscul)\n",
+    "cob(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,gauge(icl>measuring_instrument>thing))\n",
+    "mod(axle(icl>shaft>thing),maximum(icl>extremum>thing,ant>minimum):02.@maiuscul)\n",
+    "mod(load(icl>weight>thing),axle(icl>shaft>thing))\n",
+    "man(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,load(icl>weight>thing))\n",
+    "obj(load(icl>weight>thing),train(icl>public_transport>thing):07.@def)\n",
+    "mod(train(icl>public_transport>thing):07.@def,with(icl>how,com>possession,obj>thing,mod<thing))\n",
+    "obj(with(icl>how,com>possession,obj>thing,mod<thing),resolution(icl>determination>thing).@indef)\n",
+    "fictit(0.@entry,of(icl>how,com>quality,obj>thing))\n",
+    "mod(0.@entry,,5)\n",
+    "fictit(0.@entry,t-initial)\n",
+    "mod(identification(icl>determination>thing,equ>designation):01,:01)\n",
+    "val(identification(icl>determination>thing,equ>designation):02,:02.@parenthesis)\n",
+    "obj(type(icl>abstract_thing).@maiuscul,:03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The following data may be entered manually by the driver or from train memory:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@def.@topic,following(icl>adj,ant>leading))\n",
+    "obj(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@grant,data(icl>collection>thing).@def.@topic)\n",
+    "or(from(icl>how,com>origin,obj>thing),enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@grant)\n",
+    "man(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@grant,manually(icl>how,com>manual))\n",
+    "man(from(icl>how,com>origin,obj>thing),manually(icl>how,com>manual))\n",
+    "met(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@grant,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(memory(icl>basic_cognitive_process>thing),train(icl>public_transport>thing))\n",
+    "obj(from(icl>how,com>origin,obj>thing),memory(icl>basic_cognitive_process>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The following data may be entered manually by the driver provided by external sources\n",
+    ":\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Driver identification, Train identification (train number) STM ready for use, Data required for brake calculation, Maximum train speed, Train length, Status of air tight system, Type of electric power accepted, Data additional required for STM (if any), International train category, Train gauge, Maximum axle load of the train with a resolution of 0,5 t.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(0.@entry,driver(icl>operator>thing,ant>nondriver))\n",
+    "fictit(0.@entry,identification(icl>determination>thing,equ>designation):01)\n",
+    "fictit(0.@entry,train(icl>public_transport>thing):01.@maiuscul)\n",
+    "fictit(0.@entry,identification(icl>determination>thing,equ>designation):02)\n",
+    "mod:02(number(icl>abstract_thing,icl>quantity,obj>thing).@entry,train(icl>public_transport>thing):02)\n",
+    "nam(number(icl>abstract_thing,icl>quantity,obj>thing).@entry,stm:01)\n",
+    "obj:01(ready(icl>adj,ant>unready).@entry,use(icl>activity>thing))\n",
+    "aoj:03(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):01.@past,data(icl>collection>thing):01.@maiuscul)\n",
+    "obj:03(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@state,require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):01.@past)\n",
+    "mod:01(calculation(icl>procedure>thing),brake(icl>restraint>thing))\n",
+    "man:01(use(icl>activity>thing),calculation(icl>procedure>thing))\n",
+    "mod(train(icl>public_transport>thing):03,maximum(icl>extremum>thing,ant>minimum):01.@maiuscul)\n",
+    "mod(speed(icl>rate>thing),train(icl>public_transport>thing):03)\n",
+    "fictit(0.@entry,speed(icl>rate>thing))\n",
+    "mod:03(length(icl>fundamental_quantity>thing),train(icl>public_transport>thing):04.@maiuscul)\n",
+    "obj:03(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):01.@past,length(icl>fundamental_quantity>thing))\n",
+    "aoj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,status(icl>state>thing).@maiuscul)\n",
+    "mod(system(icl>group>thing),air(icl>travel>abstract_thing,equ>air_travel))\n",
+    "mod(system(icl>group>thing),tight(icl>adj,ant>loose))\n",
+    "obj(status(icl>state>thing).@maiuscul,system(icl>group>thing))\n",
+    "agt(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,type(icl>abstract_thing).@maiuscul)\n",
+    "mod:03(power(icl>quality>thing,ant>powerlessness).@entry,electric(icl>adj,com>electricity))\n",
+    "aoj:03(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@state,power(icl>quality>thing,ant>powerlessness).@entry)\n",
+    "mod:03(data(icl>collection>thing):02.@maiuscul,additional(icl>adj,equ>extra))\n",
+    "cnt:03(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):01.@past,data(icl>collection>thing):02.@maiuscul)\n",
+    "fictit(0.@entry,require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past)\n",
+    "pur(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,stm:02)\n",
+    "con(0.@entry,any(icl>adj).@parenthesis)\n",
+    "mod(category(icl>collection>thing,equ>class),international(icl>adj,ant>national).@maiuscul)\n",
+    "mod(category(icl>collection>thing,equ>class),train(icl>public_transport>thing):05)\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,category(icl>collection>thing,equ>class))\n",
+    "mod(gauge(icl>measuring_instrument>thing),train(icl>public_transport>thing):06.@maiuscul)\n",
+    "cob(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,gauge(icl>measuring_instrument>thing))\n",
+    "mod(axle(icl>shaft>thing),maximum(icl>extremum>thing,ant>minimum):02.@maiuscul)\n",
+    "mod(load(icl>weight>thing),axle(icl>shaft>thing))\n",
+    "man(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing):02.@past,load(icl>weight>thing))\n",
+    "obj(load(icl>weight>thing),train(icl>public_transport>thing):07.@def)\n",
+    "mod(train(icl>public_transport>thing):07.@def,with(icl>how,com>possession,obj>thing,mod<thing))\n",
+    "obj(with(icl>how,com>possession,obj>thing,mod<thing),resolution(icl>determination>thing).@indef)\n",
+    "fictit(0.@entry,of(icl>how,com>quality,obj>thing))\n",
+    "mod(0.@entry,,5)\n",
+    "fictit(0.@entry,t-initial)\n",
+    "mod(identification(icl>determination>thing,equ>designation):01,:01)\n",
+    "val(identification(icl>determination>thing,equ>designation):02,:02.@parenthesis)\n",
+    "obj(type(icl>abstract_thing).@maiuscul,:03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The following data may be entered manually by the driver provided by external sources\n",
+    ":. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@def.@topic,following(icl>adj,ant>leading))\n",
+    "obj(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@grant,data(icl>collection>thing).@def.@topic)\n",
+    "man(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@grant,manually(icl>how,com>manual))\n",
+    "agt(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@present.@grant,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@state,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(source(icl>abstract_thing,obj>thing).@pl,external(icl>adj,ant>internal))\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@state,source(icl>abstract_thing,obj>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If the onboard fails to contact the RBC when awakening the driver shall be asked to enter the RBC contact details\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the onboard fails to contact the RBC when awakening the driver shall be asked to enter the RBC contact details. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:02(fail(icl>disappoint>occur,cob>thing,obj>thing).@entry.@present,onboard.@def)\n",
+    "con:02(ask(icl>question>do,cob>volitional_thing,agt>volitional_thing,obj>uw).@present.@promise,fail(icl>disappoint>occur,cob>thing,obj>thing).@entry.@present)\n",
+    "cag:01(contact(icl>communicate>do,equ>reach,agt>thing,cag>thing).@entry,rbc(icl>blood_cell>thing,equ>red_blood_cell):01.@def)\n",
+    "tim:01(rbc(icl>blood_cell>thing,equ>red_blood_cell):01.@def,awaken(icl>change>do,src>thing,agt>thing,obj>living_thing))\n",
+    "cob:02(ask(icl>question>do,cob>volitional_thing,agt>volitional_thing,obj>uw).@present.@promise,driver(icl>operator>thing,ant>nondriver).@def.@topic)\n",
+    "obj:02(ask(icl>question>do,cob>volitional_thing,agt>volitional_thing,obj>uw).@present.@promise,enter(icl>do,equ>join,agt>volitional_thing,obj>thing))\n",
+    "mod:02(detail(icl>fact>thing).@def.@pl,rbc(icl>blood_cell>thing,equ>red_blood_cell):02)\n",
+    "mod:02(detail(icl>fact>thing).@def.@pl,contact(icl>interaction>thing))\n",
+    "obj:02(enter(icl>do,equ>join,agt>volitional_thing,obj>thing),detail(icl>fact>thing).@def.@pl)\n",
+    "cob:02(fail(icl>disappoint>occur,cob>thing,obj>thing).@entry.@present,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "An ETCS equipped traction unit shall be capable of being moved in Shunting without train data, track data or movement authority.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "An ETCS equipped traction unit shall be capable of being moved in Shunting without train data, track data or movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,etcs)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@indef,traction(icl>pull>thing))\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,unit(icl>measure>abstract_thing,aoj>uw).@indef)\n",
+    "aoj(capable(icl>adj).@entry.@present.@promise,unit(icl>measure>abstract_thing,aoj>uw).@indef)\n",
+    "obj(capable(icl>adj).@entry.@present.@promise,move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing))\n",
+    "man:02(shunt(icl>transfer>do,agt>thing,obj>thing).@entry.@maiuscul,without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "or:05(data(icl>collection>thing):02.@entry,data(icl>collection>thing):01.@entry)\n",
+    "mod(:05.@_hn-scope,track(icl>line>thing,equ>path))\n",
+    "mod:02(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "obj:02(without(icl>how,ant>with,com>physical,obj>thing),authority(icl>abstract_thing,obj>uw))\n",
+    "scn(move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing),:02)\n",
+    "mod(data(icl>collection>thing):01.@entry,:02)\n",
+    "or(:02,:05.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Transfer to Shunting on driver&#8217;s selection shall only be possible when stationary.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Transfer to Shunting on driver's selection shall only be possible when stationary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,transfer(icl>movement>thing,equ>transportation))\n",
+    "to(transfer(icl>movement>thing,equ>transportation),shunt(icl>transfer>do,agt>thing,obj>thing).@maiuscul)\n",
+    "plc(shunt(icl>transfer>do,agt>thing,obj>thing).@maiuscul,selection(icl>action,agt>thing,obj>thing))\n",
+    "pos(selection(icl>action,agt>thing,obj>thing),driver(icl>operator>thing,ant>nondriver))\n",
+    "man(possible(icl>adj,ant>impossible).@entry.@present.@promise,only(icl>how,com>result))\n",
+    "con(possible(icl>adj,ant>impossible).@entry.@present.@promise,when(icl>how,com>condition,obj>uw,con<uw))\n",
+    "obj(when(icl>how,com>condition,obj>uw,con<uw),stationary(icl>adj))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "To prevent unauthorised use of the function permission shall be obtained from the RBC if the train is operating under the control of the RBC.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "To prevent unauthorised use of the function permission shall be obtained from the RBC if the train is operating under the control of the RBC. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(use(icl>activity>thing),unauthorized(icl>adj,ant>authorized))\n",
+    "obj:01(prevent(icl>forestall>do,agt>thing,obj>thing).@entry.@topic,use(icl>activity>thing))\n",
+    "mod:01(permission(icl>approval>thing).@def,function(icl>mathematical_relation>thing))\n",
+    "obj:01(use(icl>activity>thing),permission(icl>approval>thing).@def)\n",
+    "src(obtain(icl>get>do,src>thing,agt>thing,obj>thing).@entry.@present.@promise,rbc(icl>blood_cell>thing,equ>red_blood_cell):01.@def)\n",
+    "obj:02(operate(icl>work>occur,obj>thing).@entry.@present.@progress,train(icl>public_transport>thing).@def)\n",
+    "plc:02(operate(icl>work>occur,obj>thing).@entry.@present.@progress,under(icl>how,equ>below,obj>thing,plc<uw))\n",
+    "obj:02(under(icl>how,equ>below,obj>thing,plc<uw),control(icl>power>thing).@def)\n",
+    "agt:02(control(icl>power>thing).@def,rbc(icl>blood_cell>thing,equ>red_blood_cell):02.@def)\n",
+    "obj(obtain(icl>get>do,src>thing,agt>thing,obj>thing).@entry.@present.@promise,:01)\n",
+    "con(obtain(icl>get>do,src>thing,agt>thing,obj>thing).@entry.@present.@promise,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Permission received shall be indicated to the driver.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Permission received shall be indicated to the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(receive(icl>acquire>do,src>thing,obj>thing).@state,permission(icl>approval>thing).@topic)\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,permission(icl>approval>thing).@topic)\n",
+    "agt(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to manually select Shunting from Stand By operation, Full Supervision operation or Partial Supervision operation\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to manually select Shunting from Stand By operation, Full Supervision operation or Partial Supervision operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw),manually(icl>how,com>manual))\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw))\n",
+    "man(shunt(icl>transfer>do,agt>thing,obj>thing).@progress.@maiuscul,from(icl>how,com>origin,obj>thing))\n",
+    "obj(from(icl>how,com>origin,obj>thing),stand(icl>support>thing,equ>base).@maiuscul)\n",
+    "met(stand(icl>support>thing,equ>base).@maiuscul,operation(icl>business_activity>thing):01)\n",
+    "mod:01(operation(icl>business_activity>thing):02.@entry,full(icl>adj,ant>empty).@maiuscul)\n",
+    "mod:01(operation(icl>business_activity>thing):02.@entry,supervision(icl>management>thing):01.@maiuscul)\n",
+    "or:01(operation(icl>business_activity>thing):03.@entry,operation(icl>business_activity>thing):02.@entry)\n",
+    "mod(:01.@_hn-scope,partial(icl>adj).@maiuscul)\n",
+    "mod:01(operation(icl>business_activity>thing):03.@entry,supervision(icl>management>thing):02.@maiuscul)\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing).@progress.@maiuscul,operation(icl>business_activity>thing):03.@entry)\n",
+    "obj(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Automatic transfer to Shunting may be from Full Supervision operation and Partial Supervision operation status at any speed lower than or equal to the supervised shunting speed based on trackside information.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Automatic transfer to Shunting may be from Full Supervision operation and Partial Supervision operation status at any speed lower than or equal to the supervised shunting speed based on trackside information. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(transfer(icl>movement>thing,equ>transportation),automatic(icl>adj,ant>manual))\n",
+    "aoj(suppose(icl>modal>be,obj>uw,aoj>thing).@entry,transfer(icl>movement>thing,equ>transportation))\n",
+    "obj(suppose(icl>modal>be,obj>uw,aoj>thing).@entry,transfer(icl>movement>thing,equ>transportation))\n",
+    "man(transfer(icl>movement>thing,equ>transportation),shunt(icl>transfer>do,agt>thing,obj>thing):01.@maiuscul)\n",
+    "mod:01(operation(icl>business_activity>thing):01.@entry,full(icl>adj,ant>empty).@maiuscul)\n",
+    "mod:01(operation(icl>business_activity>thing):01.@entry,supervision(icl>management>thing):01.@maiuscul)\n",
+    "and:01(status(icl>state>thing).@entry,operation(icl>business_activity>thing):01.@entry)\n",
+    "mod(:03.@_hn-scope,partial(icl>adj).@maiuscul)\n",
+    "mod:01(operation(icl>business_activity>thing):02,supervision(icl>management>thing):02.@maiuscul)\n",
+    "mod:01(status(icl>state>thing).@entry,operation(icl>business_activity>thing):02)\n",
+    "mod:01(speed(icl>rate>thing):01,any(icl>adj))\n",
+    "tim:01(status(icl>state>thing).@entry,speed(icl>rate>thing):01)\n",
+    "or:03(equal(icl>adj,ant>unequal).@entry,low_degree_of(icl>adj,aoj>thing).@entry)\n",
+    "mod(suppose(icl>modal>be,obj>uw,aoj>thing).@entry,than(icl>how,obj>uw,bas<thing))\n",
+    "obj:03(equal(icl>adj,ant>unequal).@entry,speed(icl>rate>thing):02.@def)\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing).@state,speed(icl>rate>thing):02.@def)\n",
+    "obj(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@state,speed(icl>rate>thing):02.@def)\n",
+    "mod(information(icl>message>thing),trackside)\n",
+    "cob(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@state,information(icl>message>thing))\n",
+    "man(:03.@_hn-scope,more(icl>how))\n",
+    "aoj:03(low_degree_of(icl>adj,aoj>thing).@entry,:01.@_hn-scope)\n",
+    "rsn(transfer(icl>movement>thing,equ>transportation),:03.@_hn-scope)\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing):02.@progress,:03.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Before authomatic transition to Shunting, ETCS shall request confirmation from the driver.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Before authomatic transition to Shunting, ETCS shall request confirmation from the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(request(icl>communicate>do,agt>volitional_thing,obj>thing).@present.@promise,before(icl>how,tim<uw,obj>thing).@entry)\n",
+    "mod(transition(icl>change_of_state>thing,equ>passage),authomatic)\n",
+    "obj(before(icl>how,tim<uw,obj>thing).@entry,transition(icl>change_of_state>thing,equ>passage))\n",
+    "man(transition(icl>change_of_state>thing,equ>passage),shunt(icl>transfer>do,agt>thing,obj>thing).@maiuscul)\n",
+    "agt(request(icl>communicate>do,agt>volitional_thing,obj>thing).@present.@promise,etcs)\n",
+    "obj(request(icl>communicate>do,agt>volitional_thing,obj>thing).@present.@promise,confirmation(icl>proof>thing))\n",
+    "mod(confirmation(icl>proof>thing),from(icl>how,equ>according_to,obj>thing))\n",
+    "obj(from(icl>how,equ>according_to,obj>thing),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "ETCS shall supervise Shunting operation to a permitted national speed value.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "ETCS shall supervise Shunting operation to a permitted national speed value. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,etcs)\n",
+    "obj:01(shunt(icl>transfer>do,agt>thing,obj>thing).@maiuscul,operation(icl>business_activity>thing))\n",
+    "mod:01(operation(icl>business_activity>thing),to(icl>how,com>content,obj>thing))\n",
+    "rec:01(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@state,national(icl>person>thing))\n",
+    "mod:01(value(icl>property,obj>thing).@entry.@indef,speed(icl>rate>thing))\n",
+    "obj:01(to(icl>how,com>content,obj>thing),value(icl>property,obj>thing).@entry.@indef)\n",
+    "obj:01(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@state,value(icl>property,obj>thing).@entry.@indef)\n",
+    "man(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The supervised Shunting speed shall be indicated to the driver on request.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The supervised Shunting speed shall be indicated to the driver on request. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing).@state,speed(icl>rate>thing).@def.@topic)\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing).@progress.@maiuscul,speed(icl>rate>thing).@def.@topic)\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,speed(icl>rate>thing).@def.@topic)\n",
+    "agt(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "plc(driver(icl>operator>thing,ant>nondriver).@def,request(icl>message>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to apply the train trip function, if the shunting movement passes a signal showing \"danger for shunting\".\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to apply the train trip function, if the shunting movement passes a signal showing \"danger for shunting\". \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:02(trip(icl>journey>thing),train(icl>public_transport>thing))\n",
+    "mod:02(function(icl>mathematical_relation>thing).@def,trip(icl>journey>thing))\n",
+    "obj:02(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing),function(icl>mathematical_relation>thing).@def)\n",
+    "agt:02(shunt(icl>transfer>do,agt>thing,obj>thing):01.@progress,movement(icl>happening>thing).@entry.@def)\n",
+    "agt:02(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present,movement(icl>happening>thing).@entry.@def)\n",
+    "con:02(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing),pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present)\n",
+    "plc:02(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present,signal(icl>communication>thing).@indef)\n",
+    "agt:02(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@progress,signal(icl>communication>thing).@indef)\n",
+    "man:01(danger(icl>condition>thing,ant>safety).@entry,shunt(icl>transfer>do,agt>thing,obj>thing):02)\n",
+    "obj:02(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@progress,:01.@double_quote)\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Exit from Shunting shall only be possible when the train is stationary.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Exit from Shunting shall only be possible when the train is stationary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,exit(icl>opening>thing))\n",
+    "obj(exit(icl>opening>thing),shunt(icl>transfer>do,agt>thing,obj>thing).@maiuscul)\n",
+    "man(possible(icl>adj,ant>impossible).@entry.@present.@promise,only(icl>how,com>result))\n",
+    "tim(possible(icl>adj,ant>impossible).@entry.@present.@promise,train(icl>public_transport>thing).@def)\n",
+    "aoj(stationary(icl>adj).@present,train(icl>public_transport>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Exit from Shunting shall take place when the driver selects exit from shunting.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Exit from Shunting shall take place when the driver selects exit from shunting. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@entry.@present.@promise,exit(icl>opening>thing):01)\n",
+    "obj(exit(icl>opening>thing):01,shunt(icl>transfer>do,agt>thing,obj>thing):01.@maiuscul)\n",
+    "obj(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@entry.@present.@promise,place(icl>space>thing,equ>seat))\n",
+    "agt:01(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj:01(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present,exit(icl>opening>thing):02)\n",
+    "obj:01(exit(icl>opening>thing):02,shunt(icl>transfer>do,agt>thing,obj>thing):02)\n",
+    "tim(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@entry.@present.@promise,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Partial Supervision shall be selected either by the Driver, or by information received from track-to-train transmission.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Partial Supervision shall be selected either by the Driver, or by information received from track-to-train transmission. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(supervision(icl>management>thing).@topic.@maiuscul,partial(icl>adj))\n",
+    "obj(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present.@promise,supervision(icl>management>thing).@topic.@maiuscul)\n",
+    "agt(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def.@maiuscul)\n",
+    "obj(either_or(icl>how,equ>or,com>two_options,obj>uw,or<uw),driver(icl>operator>thing,ant>nondriver).@def.@maiuscul)\n",
+    "or(information(icl>message>thing),either_or(icl>how,equ>or,com>two_options,obj>uw,or<uw))\n",
+    "obj(receive(icl>acquire>do,src>thing,obj>thing).@state,information(icl>message>thing))\n",
+    "mod(transmission(icl>sending>thing),track(icl>line>thing,equ>path))\n",
+    "plt(track(icl>line>thing,equ>path),train(icl>public_transport>thing))\n",
+    "src(receive(icl>acquire>do,src>thing,obj>thing).@state,transmission(icl>sending>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If acknowledgement is specified the driver shall acknowledge transfer from Full Supervision to Partial Supervision within 5 seconds\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If acknowledgement is specified the driver shall acknowledge transfer from Full Supervision to Partial Supervision within 5 seconds. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:01(specify(icl>do,equ>stipulate,agt>thing,obj>thing).@entry.@present,acknowledgement(icl>message>thing,equ>acknowledgment).@topic)\n",
+    "con:01(acknowledge(icl>communicate>do,equ>receipt,agt>volitional_thing,obj>information).@present.@promise,specify(icl>do,equ>stipulate,agt>thing,obj>thing).@entry.@present)\n",
+    "agt:01(acknowledge(icl>communicate>do,equ>receipt,agt>volitional_thing,obj>information).@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj:01(acknowledge(icl>communicate>do,equ>receipt,agt>volitional_thing,obj>information).@present.@promise,transfer(icl>movement>thing,equ>transportation))\n",
+    "mod:01(supervision(icl>management>thing):01.@maiuscul,full(icl>adj,ant>empty).@maiuscul)\n",
+    "src:01(transfer(icl>movement>thing,equ>transportation),supervision(icl>management>thing):01.@maiuscul)\n",
+    "mod:01(supervision(icl>management>thing):02.@maiuscul,partial(icl>adj).@maiuscul)\n",
+    "gol:01(transfer(icl>movement>thing,equ>transportation),supervision(icl>management>thing):02.@maiuscul)\n",
+    "dur:01(supervision(icl>management>thing):02.@maiuscul,within(icl>how,equ>during,obj>thing,dur<uw))\n",
+    "qua:01(second(icl>time_unit>thing).@pl,5)\n",
+    "obj:01(within(icl>how,equ>during,obj>thing,dur<uw),second(icl>time_unit>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Partial Supervision shall be indicated on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Partial Supervision shall be indicated on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(supervision(icl>management>thing).@topic.@maiuscul,partial(icl>adj))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,supervision(icl>management>thing).@topic.@maiuscul)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "In Partial Supervision the train shall be supervised according to train speed and distance data available.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In Partial Supervision the train shall be supervised according to train speed and distance data available. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(supervision(icl>management>thing).@maiuscul,partial(icl>adj).@maiuscul)\n",
+    "scn(promise(icl>modal>be,obj>uw,aoj>thing).@entry,supervision(icl>management>thing).@maiuscul)\n",
+    "obj:01(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry,train(icl>public_transport>thing):01.@def.@topic)\n",
+    "src:01(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry,according_to(icl>how,src>uw,obj>uw))\n",
+    "mod(:02.@_hn-scope,train(icl>public_transport>thing):02)\n",
+    "and:02(distance(icl>spacing>thing).@entry,speed(icl>rate>thing).@entry)\n",
+    "mod:01(data(icl>collection>thing),available(icl>adj,ant>unavailable))\n",
+    "obj:01(according_to(icl>how,src>uw,obj>uw),data(icl>collection>thing))\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "mod(:01,:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train shall have the capability of being supervised to a ceiling speed.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train shall have the capability of being supervised to a ceiling speed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry.@promise,train(icl>public_transport>thing).@def)\n",
+    "agt(capability(icl>ability>thing,ant>incapability).@def,train(icl>public_transport>thing).@def)\n",
+    "cob(obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry.@promise,capability(icl>ability>thing,ant>incapability).@def)\n",
+    "plt:01(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry,ceiling(icl>upper_surface>thing).@indef)\n",
+    "obj(obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry.@promise,speed(icl>travel>do,equ>rush,agt>volitional_thing))\n",
+    "obj(capability(icl>ability>thing,ant>incapability).@def,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "This ceiling speed shall not be shown continually on the DMI but may be shown momentarily when selected by the driver.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This ceiling speed shall not be shown continually on the DMI but may be shown momentarily when selected by the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(speed(icl>rate>thing).@topic,this(icl>determiner>adj,mod<concrete_thing))\n",
+    "mod:01(speed(icl>rate>thing).@topic,ceil.@progress)\n",
+    "obj:01(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing):01.@entry,speed(icl>rate>thing).@topic)\n",
+    "obj(:03.@_hn-scope,promise(icl>modal>be,obj>uw,aoj>thing).@entry.@not)\n",
+    "man:01(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing):01.@entry,continually(icl>how,com>continual))\n",
+    "plc:01(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing):01.@entry,dmi.@def)\n",
+    "and:03(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing):02.@entry.@present.@grant,but(icl>how,equ>however,obj>uw,and<uw).@entry)\n",
+    "man(but(icl>how,equ>however,obj>uw,and<uw).@entry,momentarily(icl>how))\n",
+    "agt:02(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry.@not,:01)\n",
+    "tim(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing):02.@entry.@present.@grant,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train shall leave Partial Supervision when the trainborne equipment is not operative any longer, when Shunting is selected or when Full Supervision is available.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train shall leave Partial Supervision when the trainborne equipment is not operative any longer, when Shunting is selected or when Full Supervision is available. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,train(icl>public_transport>thing).@def)\n",
+    "agt(leave(icl>refrain>do,agt>thing,obj>thing,asp>thing),train(icl>public_transport>thing).@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,leave(icl>refrain>do,agt>thing,obj>thing,asp>thing))\n",
+    "asp(leave(icl>refrain>do,agt>thing,obj>thing,asp>thing),partial(icl>adj).@maiuscul)\n",
+    "obj(leave(icl>refrain>do,agt>thing,obj>thing,asp>thing),supervision(icl>management>thing):01.@maiuscul)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "tim(leave(icl>refrain>do,agt>thing,obj>thing,asp>thing),equipment(icl>instrumentality>thing).@def)\n",
+    "aoj(operative(icl>adj,ant>inoperative).@not.@present,equipment(icl>instrumentality>thing).@def)\n",
+    "and(any(icl>adj),operative(icl>adj,ant>inoperative).@not.@present)\n",
+    "aoj(available(icl>adj,ant>unavailable).@present,any(icl>adj))\n",
+    "mod(promise(icl>modal>be,obj>uw,aoj>thing).@entry,long(icl>adj,ant>short))\n",
+    "obj:01(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present,shunt(icl>transfer>do,agt>thing,obj>thing).@topic.@maiuscul)\n",
+    "or:01(full(icl>change>do,agt>person,obj>thing).@entry.@present.@maiuscul,select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present)\n",
+    "tim(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present,when(icl>how,tim<uw,obj>uw))\n",
+    "obj:01(full(icl>change>do,agt>person,obj>thing).@entry.@present.@maiuscul,supervision(icl>management>thing):02.@maiuscul)\n",
+    "man(long(icl>adj,ant>short),more(icl>how))\n",
+    "tim(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to order a train trip when passing a stop signal\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to order a train trip when passing a stop signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,order(icl>request>do,plf>thing,agt>person,obj>thing))\n",
+    "mod(trip(icl>journey>thing).@indef,train(icl>public_transport>thing))\n",
+    "obj(order(icl>request>do,plf>thing,agt>person,obj>thing),trip(icl>journey>thing).@indef)\n",
+    "tim(trip(icl>journey>thing).@indef,pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing))\n",
+    "mod(signal(icl>communication>thing).@indef,stop(icl>stay>thing))\n",
+    "plc(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),signal(icl>communication>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Transferring to Full Supervision shall occur automatically when a movement authority and all other necessary information is received through track-to-train transmission.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Transferring to Full Supervision shall occur automatically when a movement authority and all other necessary information is received through track-to-train transmission. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw),transfer(icl>move>do,plt>thing,plf>thing,agt>thing,obj>thing))\n",
+    "mod:01(supervision(icl>management>thing).@maiuscul,full(icl>adj,ant>empty).@maiuscul)\n",
+    "plt:01(transfer(icl>move>do,plt>thing,plf>thing,agt>thing,obj>thing),supervision(icl>management>thing).@maiuscul)\n",
+    "and(:02,promise(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,occur(icl>happen>occur,cob>thing,obj>uw,plc>uw))\n",
+    "man(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw),automatically(icl>how,com>automatic))\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@indef,movement(icl>happening>thing))\n",
+    "tim(occur(icl>happen>occur,cob>thing,obj>uw,plc>uw),authority(icl>abstract_thing,obj>uw).@indef)\n",
+    "qua:02(information(icl>message>thing).@topic,all(icl>quantity,ant>some,per>thing))\n",
+    "mod:02(information(icl>message>thing).@topic,other(icl>adj,equ>different))\n",
+    "mod:02(information(icl>message>thing).@topic,necessary(icl>adj,equ>essential,ant>unnecessary,ben>volitional_thing,pur>uw))\n",
+    "obj:02(receive(icl>acquire>do,src>thing,obj>thing).@entry.@present,information(icl>message>thing).@topic)\n",
+    "plt:02(receive(icl>acquire>do,src>thing,obj>thing).@entry.@present,through(icl>how,plt<uw,obj>thing))\n",
+    "mod:02(transmission(icl>sending>thing),track(icl>line>thing,equ>path))\n",
+    "plt:02(track(icl>line>thing,equ>path),train(icl>public_transport>thing))\n",
+    "obj:02(through(icl>how,plt<uw,obj>thing),transmission(icl>sending>thing))\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible for the trackside to ask a driver for confirmation about the occupancy of the track ahead before sending a Full Supervision movement authority.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible for the trackside to ask a driver for confirmation about the occupancy of the track ahead before sending a Full Supervision movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "pur(possible(icl>adj,ant>impossible).@entry.@present.@promise,trackside.@def)\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,ask(icl>question>do,cob>volitional_thing,agt>volitional_thing,obj>uw))\n",
+    "cob(ask(icl>question>do,cob>volitional_thing,agt>volitional_thing,obj>uw),driver(icl>operator>thing,ant>nondriver).@indef)\n",
+    "obj(ask(icl>question>do,cob>volitional_thing,agt>volitional_thing,obj>uw),confirmation(icl>proof>thing))\n",
+    "mod(confirmation(icl>proof>thing),about(icl>how,equ>concerning,obj>thing))\n",
+    "obj(about(icl>how,equ>concerning,obj>thing),occupancy(icl>residency>thing).@def)\n",
+    "obj(occupancy(icl>residency>thing).@def,track(icl>line>thing,equ>path).@def)\n",
+    "mod(track(icl>line>thing,equ>path).@def,ahead(icl>how,ant>back))\n",
+    "tim(ahead(icl>how,ant>back),before(icl>how,tim<uw,obj>thing))\n",
+    "obj(before(icl>how,tim<uw,obj>thing),send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing))\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@indef,full(icl>adj,ant>empty).@maiuscul)\n",
+    "mod(movement(icl>happening>thing),supervision(icl>management>thing).@maiuscul)\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@indef,movement(icl>happening>thing))\n",
+    "obj(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing),authority(icl>abstract_thing,obj>uw).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Full Supervision shall provide supervision of speed and distance.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Full Supervision shall provide supervision of speed and distance. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(supervision(icl>management>thing):01.@maiuscul,full(icl>adj,ant>empty))\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,supervision(icl>management>thing):01.@maiuscul)\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,supervision(icl>management>thing):02)\n",
+    "and(distance(icl>spacing>thing),speed(icl>rate>thing))\n",
+    "obj(supervision(icl>management>thing):02,distance(icl>spacing>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The trainborne equipment shall remain in Full Supervision until the trainborne equipment is not active any longer, when Shunting is selected or when Partial Supervision information is received.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The trainborne equipment shall remain in Full Supervision until the trainborne equipment is not active any longer, when Shunting is selected or when Partial Supervision information is received. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(equipment(icl>instrumentality>thing):01.@def,trainborne:01)\n",
+    "aoj:01(remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing):01.@def)\n",
+    "tim:01(receive(icl>acquire>do,src>thing,obj>thing).@present,remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing).@entry.@present.@promise)\n",
+    "mod:01(supervision(icl>management>thing):01.@maiuscul,full(icl>adj,ant>empty).@maiuscul)\n",
+    "scn:01(remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing).@entry.@present.@promise,supervision(icl>management>thing):01.@maiuscul)\n",
+    "mod:01(equipment(icl>instrumentality>thing):02.@def,trainborne:02)\n",
+    "tmt:01(remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing):02.@def)\n",
+    "and:02(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present,active(icl>adj).@entry.@not.@present)\n",
+    "man(long(icl>how,com>time),any(icl>adj))\n",
+    "man(shunt(icl>transfer>do,agt>thing,obj>thing).@maiuscul,long(icl>how,com>time))\n",
+    "tim(long(icl>how,com>time),when(icl>how,tim<uw))\n",
+    "man(:02.@_hn-scope,shunt(icl>transfer>do,agt>thing,obj>thing).@maiuscul)\n",
+    "mod:01(information(icl>message>thing).@topic,partial(icl>adj).@maiuscul)\n",
+    "mod:01(information(icl>message>thing).@topic,supervision(icl>management>thing):02.@maiuscul)\n",
+    "obj:01(receive(icl>acquire>do,src>thing,obj>thing).@present,information(icl>message>thing).@topic)\n",
+    "man(long(icl>how,com>time),more(icl>how))\n",
+    "aoj:02(active(icl>adj).@entry.@not.@present,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS trainborne equipment shall be capable of being isolated.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall be capable of being isolated. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "aoj(capable(icl>adj).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "obj(capable(icl>adj).@entry.@present.@promise,isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When the ETCS trainborne equipment is isolated, the system shall not show any ETCS information other than the fact that the system is isolated.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When the ETCS trainborne equipment is isolated, the system shall not show any ETCS information other than the fact that the system is isolated. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@not.@present.@promise,when(icl>how,com>always,tim<uw,obj>uw).@entry)\n",
+    "mod(trainborne,etcs:01)\n",
+    "mod(equipment(icl>instrumentality>thing).@def.@topic,trainborne)\n",
+    "obj(isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing):01.@present,equipment(icl>instrumentality>thing).@def.@topic)\n",
+    "obj(when(icl>how,com>always,tim<uw,obj>uw).@entry,isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing):01.@present)\n",
+    "agt(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@not.@present.@promise,system(icl>group>thing):01.@def)\n",
+    "mod(information(icl>message>thing),any(icl>adj))\n",
+    "mod(information(icl>message>thing),etcs:02)\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@not.@present.@promise,information(icl>message>thing))\n",
+    "mod(information(icl>message>thing),other(icl>adj,equ>different))\n",
+    "bas(other(icl>adj,equ>different),than(icl>how,equ>but_not,obj>uw,bas<thing))\n",
+    "obj(than(icl>how,equ>but_not,obj>uw,bas<thing),fact(icl>information>thing).@def)\n",
+    "obj(isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing):02.@present,system(icl>group>thing):02.@def.@topic)\n",
+    "obj(fact(icl>information>thing).@def,isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing):02.@present)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Isolation of the ETCS trainborne equipment shall disconnect the ETCS trainborne equipment from the vehicle braking system.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Isolation of the ETCS trainborne equipment shall disconnect the ETCS trainborne equipment from the vehicle braking system. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(disconnect(icl>separate>do,cob>concrete_thing,agt>thing,obj>thing).@entry.@present.@promise,isolation(icl>separation>thing))\n",
+    "mod(trainborne:01,etcs:01)\n",
+    "mod(equipment(icl>instrumentality>thing):01.@def,trainborne:01)\n",
+    "obj(isolation(icl>separation>thing),equipment(icl>instrumentality>thing):01.@def)\n",
+    "mod(trainborne:02,etcs:02)\n",
+    "mod(equipment(icl>instrumentality>thing):02.@def,trainborne:02)\n",
+    "obj(disconnect(icl>separate>do,cob>concrete_thing,agt>thing,obj>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing):02.@def)\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,vehicle(icl>functional_thing,pur>thing))\n",
+    "cob(disconnect(icl>separate>do,cob>concrete_thing,agt>thing,obj>thing).@entry.@present.@promise,system(icl>group>thing).@def)\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,system(icl>group>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS trainborne equipment shall be capable of receiving information from the national train control systems by means of the STM.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall be capable of receiving information from the national train control systems by means of the STM. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "aoj(capable(icl>adj).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "obj(capable(icl>adj).@entry.@present.@promise,receive(icl>acquire>do,src>thing,obj>thing))\n",
+    "obj(receive(icl>acquire>do,src>thing,obj>thing),information(icl>message>thing))\n",
+    "mod(system(icl>group>thing).@def.@pl,national(icl>adj,ant>international))\n",
+    "mod(control(icl>power>thing),train(icl>public_transport>thing))\n",
+    "mod(system(icl>group>thing).@def.@pl,control(icl>power>thing))\n",
+    "src(receive(icl>acquire>do,src>thing,obj>thing),system(icl>group>thing).@def.@pl)\n",
+    "met(system(icl>group>thing).@def.@pl,means(icl>abstract_thing,equ>instrument,mod>thing,pur>thing))\n",
+    "mod(means(icl>abstract_thing,equ>instrument,mod>thing,pur>thing),stm.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The DMI shall display or be compatible with information from national train control systems. This may mean displaying the information shown by the national system.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The DMI shall display or be compatible with information from national train control systems. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,dmi.@def)\n",
+    "aoj(compatible(icl>adj,ant>incompatible),display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry.@present.@promise)\n",
+    "obj(compatible(icl>adj,ant>incompatible),information(icl>message>thing))\n",
+    "mod(information(icl>message>thing),from(icl>how,com>origin,obj>thing))\n",
+    "mod(system(icl>group>thing).@pl,national(icl>adj,ant>international))\n",
+    "mod(control(icl>power>thing),train(icl>public_transport>thing))\n",
+    "mod(system(icl>group>thing).@pl,control(icl>power>thing))\n",
+    "obj(from(icl>how,com>origin,obj>thing),system(icl>group>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This may mean displaying the information shown by the national system. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(mean(icl>necessitate>be,equ>entail,obj>uw,aoj>uw).@entry.@present.@suppose,this(icl>thing,equ>it,equ>that))\n",
+    "obj(mean(icl>necessitate>be,equ>entail,obj>uw,aoj>uw).@entry.@present.@suppose,display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing))\n",
+    "obj(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing),information(icl>message>thing).@def)\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@state,information(icl>message>thing).@def)\n",
+    "mod(system(icl>group>thing).@def,national(icl>adj,ant>international))\n",
+    "agt(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@state,system(icl>group>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Unfitted operation shall be possible if ordered by trackside\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Unfitted operation shall be possible if ordered by trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(unfit(icl>change>do,equ>disqualify,rsn>thing,agt>thing,obj>thing).@state,operation(icl>business_activity>thing))\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,operation(icl>business_activity>thing))\n",
+    "agt:01(order(icl>request>do,plf>thing,agt>person,obj>thing).@entry,trackside)\n",
+    "con(possible(icl>adj,ant>impossible).@entry.@present.@promise,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Unfitted operation shall be possible if selected by the driver at start up\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Unfitted operation shall be possible if selected by the driver at start up. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(unfit(icl>change>do,equ>disqualify,rsn>thing,agt>thing,obj>thing).@state,operation(icl>business_activity>thing))\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,operation(icl>business_activity>thing))\n",
+    "agt:01(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "tim:01(driver(icl>operator>thing,ant>nondriver).@def,start(icl>beginning>thing))\n",
+    "man:01(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry,up(icl>how,com>height))\n",
+    "con(possible(icl>adj,ant>impossible).@entry.@present.@promise,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The on board shall supervise the train against a ceiling speed\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ceiling speed value for the unfitted operation is determined by the lower value out of\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Maximum train speed, National value for unfitted operation.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(train(icl>public_transport>thing),maximum(icl>extremum>thing,ant>minimum))\n",
+    "mod(speed(icl>rate>thing).@entry,train(icl>public_transport>thing))\n",
+    "mod:01(value(icl>property,obj>thing),national(icl>adj,ant>international).@maiuscul)\n",
+    "pur:01(value(icl>property,obj>thing),operation(icl>business_activity>thing).@entry)\n",
+    "obj:01(unfit(icl>change>do,equ>disqualify,rsn>thing,agt>thing,obj>thing).@state,operation(icl>business_activity>thing).@entry)\n",
+    "cnt(speed(icl>rate>thing).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ceiling speed value for the unfitted operation is determined by the lower value out of. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(value(icl>property,obj>thing):01.@topic,ceiling(icl>upper_surface>thing).@def)\n",
+    "mod(value(icl>property,obj>thing):01.@topic,speed(icl>rate>thing))\n",
+    "obj(determine(icl>cause>be,equ>shape,obj>thing,aoj>thing).@entry.@present,value(icl>property,obj>thing):01.@topic)\n",
+    "pur(value(icl>property,obj>thing):01.@topic,operation(icl>business_activity>thing).@def)\n",
+    "obj(unfit(icl>change>do,equ>disqualify,rsn>thing,agt>thing,obj>thing).@state,operation(icl>business_activity>thing).@def)\n",
+    "mod(value(icl>property,obj>thing):02.@def,low(icl>adj,ant>high))\n",
+    "aoj(determine(icl>cause>be,equ>shape,obj>thing,aoj>thing).@entry.@present,value(icl>property,obj>thing):02.@def)\n",
+    "plf(determine(icl>cause>be,equ>shape,obj>thing,aoj>thing).@entry.@present,out_of(icl>how,plf<uw,obj>thing))\n",
+    "man(low(icl>adj,ant>high),more(icl>how))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The onboard shall be capable to switch to another ETCS status when transmitted from trackside\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The onboard shall be capable to switch to another ETCS status when transmitted from trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(capable(icl>adj).@entry.@present.@promise,onboard.@def)\n",
+    "pur(onboard.@def,switch(icl>switch_over>occur,src>uw,obj>thing,gol>uw))\n",
+    "mod(status(icl>state>thing),another(icl>adj,equ>another))\n",
+    "mod(status(icl>state>thing),etcs)\n",
+    "gol(switch(icl>switch_over>occur,src>uw,obj>thing,gol>uw),status(icl>state>thing))\n",
+    "tim(status(icl>state>thing),transmit(icl>pass>do,agt>thing,obj>thing,ben>thing))\n",
+    "plf(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),trackside)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS on-board shall be capable of receiving track description from the trackside.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS on-board shall be capable of receiving track description from the trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "aoj(capable(icl>adj),etcs.@def)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on-board)\n",
+    "mod:01(description(icl>statement>thing),track(icl>line>thing,equ>path))\n",
+    "obj:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,description(icl>statement>thing))\n",
+    "src:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,trackside.@def)\n",
+    "obj(capable(icl>adj),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to send information on adhesion conditions from trackside.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to send information on adhesion conditions from trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing))\n",
+    "obj(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing),information(icl>message>thing))\n",
+    "mod(condition(icl>state>abstract_thing,aoj>thing).@pl,adhesion(icl>pathology>thing))\n",
+    "obj(information(icl>message>thing),condition(icl>state>abstract_thing,aoj>thing).@pl)\n",
+    "plf(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing),trackside)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall also be possible, to allow the driver to change the adhesion conditions; in this case information from trackside has priority.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall also be possible, to allow the driver to change the adhesion conditions; in this case information from trackside has priority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(:03,promise(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "man(possible(icl>adj,ant>impossible),also(icl>how,equ>besides))\n",
+    "aoj(possible(icl>adj,ant>impossible),allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing))\n",
+    "agt:02(change(icl>do,src>thing,agt>thing,obj>uw,gol>thing).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod:02(condition(icl>state>abstract_thing,aoj>thing).@def.@pl,adhesion(icl>pathology>thing))\n",
+    "obj:02(change(icl>do,src>thing,agt>thing,obj>uw,gol>thing).@entry,condition(icl>state>abstract_thing,aoj>thing).@def.@pl)\n",
+    "mod:03(case(icl>happening>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "scn:03(have(icl>be,equ>possess,obj>thing,aoj>thing).@entry.@present,case(icl>happening>thing))\n",
+    "aoj:03(have(icl>be,equ>possess,obj>thing,aoj>thing).@entry.@present,information(icl>message>thing))\n",
+    "frm:03(information(icl>message>thing),trackside)\n",
+    "obj:03(have(icl>be,equ>possess,obj>thing,aoj>thing).@entry.@present,priority(icl>high_status>thing,equ>precedence))\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "obj:01(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing),:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The trackside shall be able to send information for the calculation of speed profiles.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The trackside shall be able to send information for the calculation of speed profiles. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(send_for(icl>call_for>do,plt>uw,plf>uw,agt>thing,obj>person,pur>uw).@entry.@present.@ability.@promise,trackside.@def)\n",
+    "obj(send_for(icl>call_for>do,plt>uw,plf>uw,agt>thing,obj>person,pur>uw).@entry.@present.@ability.@promise,information(icl>message>thing))\n",
+    "pur(send_for(icl>call_for>do,plt>uw,plf>uw,agt>thing,obj>person,pur>uw).@entry.@present.@ability.@promise,calculation(icl>procedure>thing).@def)\n",
+    "mod(profile(icl>chart>thing).@pl,speed(icl>rate>thing))\n",
+    "obj(calculation(icl>procedure>thing).@def,profile(icl>chart>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If track data at least to the location where the relevant movement authority ends are not available on-board, the movement authority shall be rejected.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If track data at least to the location where the relevant movement authority ends are not available on-board, the movement authority shall be rejected. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@entry.@pl,track(icl>line>thing,equ>path))\n",
+    "aoj(on-board.@not.@present,data(icl>collection>thing).@entry.@pl)\n",
+    "con(reject(icl>evaluate>do,agt>thing,obj>thing).@present.@promise,data(icl>collection>thing).@entry.@pl)\n",
+    "man(data(icl>collection>thing).@entry.@pl,at_least(icl>how))\n",
+    "plt(data(icl>collection>thing).@entry.@pl,location(icl>object>thing).@def)\n",
+    "plc(end(icl>be,equ>stop,aoj>thing,plc>concrete_thing).@present,location(icl>object>thing).@def)\n",
+    "mod(authority(icl>abstract_thing,obj>uw):01.@def,relevant(icl>adj,ant>irrelevant))\n",
+    "mod(authority(icl>abstract_thing,obj>uw):01.@def,movement(icl>happening>thing):01)\n",
+    "aoj(end(icl>be,equ>stop,aoj>thing,plc>concrete_thing).@present,authority(icl>abstract_thing,obj>uw):01.@def)\n",
+    "and(available(icl>adj,ant>unavailable),on-board.@not.@present)\n",
+    "mod(authority(icl>abstract_thing,obj>uw):02.@def.@topic,movement(icl>happening>thing):02)\n",
+    "obj(reject(icl>evaluate>do,agt>thing,obj>thing).@present.@promise,authority(icl>abstract_thing,obj>uw):02.@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track to train transmission shall provide the capability to send different speed profiles for specific train categories.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track to train transmission shall provide the capability to send different speed profiles for specific train categories. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,track(icl>line>thing,equ>path))\n",
+    "mod(transmission(icl>sending>thing),train(icl>public_transport>thing):01)\n",
+    "to(track(icl>line>thing,equ>path),transmission(icl>sending>thing))\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,capability(icl>ability>thing,ant>incapability).@def)\n",
+    "mod:01(speed(icl>rate>thing),different(icl>adj,ant>same))\n",
+    "mod:01(profile(icl>chart>thing).@pl,speed(icl>rate>thing))\n",
+    "obj:01(send_for(icl>call_for>do,plt>uw,plf>uw,agt>thing,obj>person,pur>uw).@entry,profile(icl>chart>thing).@pl)\n",
+    "mod:01(category(icl>collection>thing,equ>class).@pl,specific(icl>adj,equ>particular,ant>general))\n",
+    "mod:01(category(icl>collection>thing,equ>class).@pl,train(icl>public_transport>thing):02)\n",
+    "pur:01(send_for(icl>call_for>do,plt>uw,plf>uw,agt>thing,obj>person,pur>uw).@entry,category(icl>collection>thing,equ>class).@pl)\n",
+    "obj(capability(icl>ability>thing,ant>incapability).@def,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS trainborne equipment shall supervise the end of movement authority, if this information is available on-board.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall supervise the end of movement authority, if this information is available on-board. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "agt(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,end(icl>moment>time,ant>beginning).@def)\n",
+    "mod(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "agt(end(icl>moment>time,ant>beginning).@def,authority(icl>abstract_thing,obj>uw))\n",
+    "mod(information(icl>message>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "con(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,information(icl>message>thing))\n",
+    "aoj(on-board.@present,information(icl>message>thing))\n",
+    "and(available(icl>adj,ant>unavailable),on-board.@present)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The target distance to be displayed on the DMI shall be based on the most restrictive braking curve.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The target distance to be displayed on the DMI shall be based on the most restrictive braking curve. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(distance(icl>spacing>thing).@def.@topic,target(icl>reference_point>thing))\n",
+    "obj(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present.@promise,distance(icl>spacing>thing).@def.@topic)\n",
+    "plc:01(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry,on)\n",
+    "obj:01(on,dmi.@def)\n",
+    "man(restrictive(icl>adj,ant>unrestrictive),most(icl>how))\n",
+    "mod(curve(icl>line>thing,ant>straight_line).@def,restrictive(icl>adj,ant>unrestrictive))\n",
+    "cob(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present.@promise,curve(icl>line>thing,ant>straight_line).@def)\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,curve(icl>line>thing,ant>straight_line).@def)\n",
+    "pur(distance(icl>spacing>thing).@def.@topic,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Together with the movement authority, the on board shall be able to receive one or more time-out(s) for certain sections of the movement authority, and shorten the movement authority accordingly when a time out expires.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Together with the movement authority, the on board shall be able to receive one or more time-out(s) for certain sections of the movement authority, and shorten the movement authority accordingly when a time out expires. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,together(icl>how,equ>jointly,com>joint))\n",
+    "mod(authority(icl>abstract_thing,obj>uw):01.@def,movement(icl>happening>thing):01)\n",
+    "obj(together(icl>how,equ>jointly,com>joint),authority(icl>abstract_thing,obj>uw):01.@def)\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on board)\n",
+    "qua:02(timeout,one(icl>digit>thing).@entry)\n",
+    "qua:02(timeout,more(icl>quantity,ant>less,qua<thing,bas>uw))\n",
+    "obj:02(receive(icl>acquire>do,src>thing,obj>thing).@ability,timeout)\n",
+    "cnt:02(timeout,s.@parenthesis)\n",
+    "mod:02(section(icl>writing>thing).@pl,certain(icl>adj,equ>certain))\n",
+    "ben:02(timeout,section(icl>writing>thing).@pl)\n",
+    "mod:02(authority(icl>abstract_thing,obj>uw):02.@def,movement(icl>happening>thing):02)\n",
+    "obj:02(section(icl>writing>thing).@pl,authority(icl>abstract_thing,obj>uw):02.@def)\n",
+    "mod:03(authority(icl>abstract_thing,obj>uw):03.@def,movement(icl>happening>thing):03)\n",
+    "obj:03(shorten(icl>reduce>do,agt>thing,obj>thing).@entry,authority(icl>abstract_thing,obj>uw):03.@def)\n",
+    "man:03(shorten(icl>reduce>do,agt>thing,obj>thing).@entry,accordingly(icl>how,equ>consequently,com>consequent))\n",
+    "mod:04(out(icl>failure>thing).@indef,time(icl>abstract_thing,equ>occasion))\n",
+    "obj:04(expire(icl>discontinue>occur,equ>run_out,obj>thing,man>thing).@entry.@present,out(icl>failure>thing).@indef)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "obj(or(icl>how,obj>uw,or<uw),:02)\n",
+    "and(:03,:02)\n",
+    "obj:01(be(icl>be).@entry,:03)\n",
+    "tim:03(shorten(icl>reduce>do,agt>thing,obj>thing).@entry,:04)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Using train data and infrastructure data, braking curves shall be calculated taking into account the target information but not the location of vehicles occupying the track.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Using train data and infrastructure data, braking curves shall be calculated taking into account the target information but not the location of vehicles occupying the track. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present.@promise,use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@topic)\n",
+    "and:06(data(icl>collection>thing):02.@entry,data(icl>collection>thing):01.@entry)\n",
+    "mod(:06.@_hn-scope,infrastructure(icl>structure>thing))\n",
+    "man(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present.@promise,take(icl>require>be,obj>thing,aoj>thing,ben>person))\n",
+    "plt(take(icl>require>be,obj>thing,aoj>thing,ben>person),account(icl>agreement(icl>abstract_thing)))\n",
+    "mod(information(icl>message>thing).@def,target(icl>reference_point>thing))\n",
+    "obj(take(icl>require>be,obj>thing,aoj>thing,ben>person),information(icl>message>thing).@def)\n",
+    "obj(but(icl>how,equ>however,obj>uw,and<uw),information(icl>message>thing).@def)\n",
+    "and(location(icl>object>thing).@def.@not,but(icl>how,equ>however,obj>uw,and<uw))\n",
+    "obj(location(icl>object>thing).@def.@not,vehicle(icl>functional_thing,pur>thing).@pl)\n",
+    "aoj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@progress,vehicle(icl>functional_thing,pur>thing).@pl)\n",
+    "obj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@progress,track(icl>line>thing,equ>path).@def)\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@topic,:06.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ceiling speed level for the movement authority shall be defined as data National Value.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ceiling speed level for the movement authority shall be defined as data National Value. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(speed(icl>rate>thing),ceil.@progress)\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@topic,speed(icl>rate>thing))\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present.@promise,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@topic)\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@def,movement(icl>happening>thing))\n",
+    "ben(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@def.@topic,authority(icl>abstract_thing,obj>uw).@def)\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present.@promise,as(icl>how,com>class,obj>thing,aoj<uw))\n",
+    "mod(value(icl>property,obj>thing).@maiuscul,data(icl>collection>thing))\n",
+    "mod(value(icl>property,obj>thing).@maiuscul,national(icl>adj,ant>international).@maiuscul)\n",
+    "obj(as(icl>how,com>class,obj>thing,aoj<uw),value(icl>property,obj>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Before entering an occupied track, a driver acknowledgement shall be requested.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Before entering an occupied track, a driver acknowledgement shall be requested. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim:01(request(icl>communicate>do,agt>volitional_thing,obj>thing).@present.@promise,before(icl>how,tim<uw,obj>thing).@entry)\n",
+    "obj:01(before(icl>how,tim<uw,obj>thing).@entry,enter(icl>do,equ>join,agt>volitional_thing,obj>thing))\n",
+    "obj:01(enter(icl>do,equ>join,agt>volitional_thing,obj>thing),track(icl>line>thing,equ>path).@indef)\n",
+    "obj:01(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@state,track(icl>line>thing,equ>path).@indef)\n",
+    "mod:01(acknowledgement(icl>message>thing,equ>acknowledgment).@indef.@topic,driver(icl>operator>thing,ant>nondriver))\n",
+    "obj:01(request(icl>communicate>do,agt>volitional_thing,obj>thing).@present.@promise,acknowledgement(icl>message>thing,equ>acknowledgment).@indef.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train shall be supervised according to train speed data available.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train shall be supervised according to train speed data available. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,train(icl>public_transport>thing):01.@def.@topic)\n",
+    "src(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,according_to(icl>how,src>uw,obj>uw))\n",
+    "mod(speed(icl>rate>thing),train(icl>public_transport>thing):02)\n",
+    "mod(data(icl>collection>thing),speed(icl>rate>thing))\n",
+    "mod(data(icl>collection>thing),available(icl>adj,ant>unavailable))\n",
+    "obj(according_to(icl>how,src>uw,obj>uw),data(icl>collection>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train shall, as a minimum, be supervised to a ceiling speed; the supervised speed shall not be shown on the DMI unless selected by the driver.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train shall, as a minimum, be supervised to a ceiling speed; the supervised speed shall not be shown on the DMI unless selected by the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:01(supervise(icl>control>do,agt>volitional_thing,obj>thing):01.@entry,train(icl>public_transport>thing).@def.@topic)\n",
+    "man:02(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@not.@present.@promise,promise(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "man:02(promise(icl>modal>be,obj>uw,aoj>thing).@entry,as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj:02(as(icl>how,com>degree,obj>uw,man<uw),minimum(icl>extremum>thing,ant>maximum).@indef)\n",
+    "mod:01(speed(icl>rate>thing):01,ceil.@indef.@progress)\n",
+    "to:01(supervise(icl>control>do,agt>volitional_thing,obj>thing):01.@entry,speed(icl>rate>thing):01)\n",
+    "obj:02(supervise(icl>control>do,agt>volitional_thing,obj>thing):02.@state,speed(icl>rate>thing):02.@def.@topic)\n",
+    "obj:02(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@not.@present.@promise,speed(icl>rate>thing):02.@def.@topic)\n",
+    "plc:02(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@not.@present.@promise,dmi.@def)\n",
+    "con:02(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@not.@present.@promise,unless(icl>how,obj>uw,con<uw))\n",
+    "obj:02(unless(icl>how,obj>uw,con<uw),select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw))\n",
+    "agt:02(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj:02(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The target distance shall not be shown on the DMI unless selected by the driver.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The target distance shall not be shown on the DMI unless selected by the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(distance(icl>spacing>thing).@def.@topic,target(icl>reference_point>thing))\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@not.@present.@promise,distance(icl>spacing>thing).@def.@topic)\n",
+    "plc(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@not.@present.@promise,dmi.@def)\n",
+    "con(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@not.@present.@promise,unless(icl>how,obj>uw,con<uw))\n",
+    "agt:01(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(unless(icl>how,obj>uw,con<uw),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "On request of the RBC, the driver shall have the possibility to confirm that the track ahead of him until the end of the on sight section is clear\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "On request of the RBC, the driver shall have the possibility to confirm that the track ahead of him until the end of the on sight section is clear. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(have(icl>be,obj>thing,aoj>thing).@present.@promise,request(icl>message>thing).@entry)\n",
+    "agt(request(icl>message>thing).@entry,rbc(icl>blood_cell>thing,equ>red_blood_cell).@def)\n",
+    "aoj(have(icl>be,obj>thing,aoj>thing).@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(have(icl>be,obj>thing,aoj>thing).@present.@promise,possibility(icl>perspective>abstract_thing,obj>uw).@def)\n",
+    "obj(possibility(icl>perspective>abstract_thing,obj>uw).@def,confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing))\n",
+    "obj(confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing),that(icl>thing,equ>it,equ>this))\n",
+    "cob(have(icl>be,obj>thing,aoj>thing).@present.@promise,track(icl>line>thing,equ>path).@def)\n",
+    "plc(track(icl>line>thing,equ>path).@def,ahead_of(icl>how,obj>thing,plc<uw))\n",
+    "obj(ahead_of(icl>how,obj>thing,plc<uw),he(icl>person))\n",
+    "tmt(track(icl>line>thing,equ>path).@def,end(icl>moment>time,ant>beginning).@def)\n",
+    "obj(end(icl>moment>time,ant>beginning).@def,of(icl>how,com>quality,obj>thing))\n",
+    "plc(clear(icl>adj,ant>unclear).@present,sight(icl>visual_percept>thing).@def)\n",
+    "obj(track(icl>line>thing,equ>path).@def,section(icl>writing>thing))\n",
+    "aoj(clear(icl>adj,ant>unclear).@present,section(icl>writing>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "ETCS shall collect all relevant information concerning train and line speed.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "ETCS shall collect all relevant information concerning train and line speed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(collect(icl>do,equ>gather,agt>volitional_thing,obj>thing).@entry.@present.@promise,etcs)\n",
+    "and(:01,collect(icl>do,equ>gather,agt>volitional_thing,obj>thing).@entry.@present.@promise)\n",
+    "qua(information(icl>message>thing),all(icl>quantity,ant>some,per>thing))\n",
+    "mod(information(icl>message>thing),relevant(icl>adj,ant>irrelevant))\n",
+    "obj(collect(icl>do,equ>gather,agt>volitional_thing,obj>thing).@entry.@present.@promise,information(icl>message>thing))\n",
+    "mod(information(icl>message>thing),concerning(icl>how,equ>about,obj>thing))\n",
+    "obj(concerning(icl>how,equ>about,obj>thing),train(icl>public_transport>thing))\n",
+    "plc:01(line(icl>be_situated>be,aoj>thing,plc>thing).@entry,speed(icl>rate>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "ETCS shall calculate the permitted speed for the train for all locations of the authorised movement.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "ETCS shall calculate the permitted speed for the train for all locations of the authorised movement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present.@promise,etcs)\n",
+    "obj(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present.@promise,speed(icl>rate>thing).@def)\n",
+    "obj(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@state,speed(icl>rate>thing).@def)\n",
+    "plt(speed(icl>rate>thing).@def,train(icl>public_transport>thing).@def)\n",
+    "qua(location(icl>object>thing).@pl,all(icl>quantity,ant>some,per>thing))\n",
+    "plt(train(icl>public_transport>thing).@def,location(icl>object>thing).@pl)\n",
+    "obj(location(icl>object>thing).@pl,movement(icl>happening>thing).@def)\n",
+    "obj(authorize(icl>permit>do,agt>volitional_thing,obj>thing,ben>thing).@state,movement(icl>happening>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "This static train speed profile shall also respect maximum line speed and track speed and special speed levels for special classes of trains.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This static train speed profile shall also respect maximum line speed and track speed and special speed levels for special classes of trains. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(profile(icl>chart>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "mod(profile(icl>chart>thing),static(icl>adj,equ>inactive))\n",
+    "mod(speed(icl>rate>thing):01,train(icl>public_transport>thing):01)\n",
+    "mod(profile(icl>chart>thing),speed(icl>rate>thing):01)\n",
+    "aoj(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@entry.@present.@promise,profile(icl>chart>thing))\n",
+    "man(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@entry.@present.@promise,also(icl>how,equ>besides))\n",
+    "mod:01(line(icl>formation>thing),maximum(icl>extremum>thing,ant>minimum))\n",
+    "mod:01(speed(icl>rate>thing):02.@entry,line(icl>formation>thing))\n",
+    "mod(speed(icl>rate>thing):02.@entry,track(icl>line>thing,equ>path))\n",
+    "and:03(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry.@pl,speed(icl>rate>thing):03.@entry)\n",
+    "mod:01(speed(icl>rate>thing):04,special(icl>adj,equ>particular):01)\n",
+    "mod:03(class(icl>people>thing).@pl,special(icl>adj,equ>particular):02)\n",
+    "ben:03(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry.@pl,class(icl>people>thing).@pl)\n",
+    "obj:03(class(icl>people>thing).@pl,train(icl>public_transport>thing):02.@pl)\n",
+    "and:03(speed(icl>rate>thing):03.@entry,:01.@_hn-scope)\n",
+    "mod:03(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@entry.@pl,:01.@_hn-scope)\n",
+    "obj(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@entry.@present.@promise,:03.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS trainborne equipment calculates the static train speed profile on the basis of infrastructure data and train data.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment calculates the static train speed profile on the basis of infrastructure data and train data. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "agt(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present,equipment(icl>instrumentality>thing).@def)\n",
+    "mod(profile(icl>chart>thing).@def,static(icl>adj,equ>inactive))\n",
+    "mod(speed(icl>rate>thing),train(icl>public_transport>thing):01)\n",
+    "mod(profile(icl>chart>thing).@def,speed(icl>rate>thing))\n",
+    "obj(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present,profile(icl>chart>thing).@def)\n",
+    "mod(profile(icl>chart>thing).@def,on_the_basis_of(icl>how,obj>thing))\n",
+    "mod:01(data(icl>collection>thing):01.@entry,infrastructure(icl>structure>thing))\n",
+    "and:01(data(icl>collection>thing):02.@entry,data(icl>collection>thing):01.@entry)\n",
+    "mod(data(icl>collection>thing):01.@entry,train(icl>public_transport>thing):02)\n",
+    "obj(on_the_basis_of(icl>how,obj>thing),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Based on all relevant data, the ETCS shall calculate an emergency braking curve and a service braking curve\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Based on all relevant data, the ETCS shall calculate an emergency braking curve and a service braking curve. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "qua:01(data(icl>collection>thing).@pl,all(icl>quantity,ant>some,per>thing))\n",
+    "mod:01(data(icl>collection>thing).@pl,relevant(icl>adj,ant>irrelevant))\n",
+    "cob:01(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry,data(icl>collection>thing).@pl)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "agt(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism),etcs.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism))\n",
+    "obj(brake(icl>stop>occur,obj>thing):01.@progress,emergency(icl>crisis>thing))\n",
+    "and(curve(icl>line>thing,ant>straight_line):02.@indef,curve(icl>line>thing,ant>straight_line):01.@indef)\n",
+    "obj(brake(icl>stop>occur,obj>thing):02.@progress,service(icl>work>action,agt>thing,obj>thing))\n",
+    "obj(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism),curve(icl>line>thing,ant>straight_line):02.@indef)\n",
+    "obj(brake(icl>stop>occur,obj>thing):01.@progress,curve(icl>line>thing,ant>straight_line):02.@indef)\n",
+    "obj(brake(icl>stop>occur,obj>thing):02.@progress,curve(icl>line>thing,ant>straight_line):02.@indef)\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Based on all relevant data, the ETCS shall calculate an emergency braking curve and a service braking curve\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Based on all relevant data, the ETCS shall calculate an emergency braking curve and a service braking curve. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "qua:01(data(icl>collection>thing).@pl,all(icl>quantity,ant>some,per>thing))\n",
+    "mod:01(data(icl>collection>thing).@pl,relevant(icl>adj,ant>irrelevant))\n",
+    "cob:01(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry,data(icl>collection>thing).@pl)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "agt(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism),etcs.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism))\n",
+    "obj(brake(icl>stop>occur,obj>thing):01.@progress,emergency(icl>crisis>thing))\n",
+    "and(curve(icl>line>thing,ant>straight_line):02.@indef,curve(icl>line>thing,ant>straight_line):01.@indef)\n",
+    "obj(brake(icl>stop>occur,obj>thing):02.@progress,service(icl>work>action,agt>thing,obj>thing))\n",
+    "obj(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism),curve(icl>line>thing,ant>straight_line):02.@indef)\n",
+    "obj(brake(icl>stop>occur,obj>thing):01.@progress,curve(icl>line>thing,ant>straight_line):02.@indef)\n",
+    "obj(brake(icl>stop>occur,obj>thing):02.@progress,curve(icl>line>thing,ant>straight_line):02.@indef)\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When changing to a lower speed level, the front end of the train shall respect the dynamic train speed profile.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When changing to a lower speed level, the front end of the train shall respect the dynamic train speed profile. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim:01(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,change(icl>occur,src>thing,obj>thing,gol>thing).@entry)\n",
+    "plc:01(change(icl>occur,src>thing,obj>thing,gol>thing).@entry,to(icl>how,com>direction,obj>thing,plc<uw))\n",
+    "mod:01(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@indef,speed(icl>rate>thing):01)\n",
+    "obj:01(to(icl>how,com>direction,obj>thing,plc<uw),level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@indef)\n",
+    "aoj(low_degree_of(icl>adj,aoj>thing).@entry,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@indef)\n",
+    "mod:01(end(icl>moment>time,ant>beginning).@def,front(icl>adj,equ>front,ant>back))\n",
+    "aoj:01(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,end(icl>moment>time,ant>beginning).@def)\n",
+    "obj:01(end(icl>moment>time,ant>beginning).@def,train(icl>public_transport>thing):01.@def)\n",
+    "mod:01(train(icl>public_transport>thing):02,dynamic(icl>adj,ant>undynamic))\n",
+    "mod:01(speed(icl>rate>thing):02,train(icl>public_transport>thing):02)\n",
+    "mod:01(profile(icl>chart>thing).@def,speed(icl>rate>thing):02)\n",
+    "obj:01(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,profile(icl>chart>thing).@def)\n",
+    "man(low_degree_of(icl>adj,aoj>thing).@entry,more(icl>how))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When changing to a higher speed level the rear end of the train shall respect the static train speed profile.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When changing to a higher speed level the rear end of the train shall respect the static train speed profile. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(when(icl>how,tim<uw,obj>uw).@entry,change(icl>do,src>thing,agt>thing,obj>uw,gol>thing))\n",
+    "plc(change(icl>do,src>thing,agt>thing,obj>uw,gol>thing),to(icl>how,com>direction,obj>thing,plc<uw))\n",
+    "mod(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@indef,speed(icl>rate>thing):01)\n",
+    "obj(to(icl>how,com>direction,obj>thing,plc<uw),level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@indef)\n",
+    "aoj(high_degree_of(icl>adj,aoj>thing),level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@indef)\n",
+    "mod(end(icl>moment>time,ant>beginning).@def,rear(icl>adj,equ>rear))\n",
+    "obj(change(icl>do,src>thing,agt>thing,obj>uw,gol>thing),end(icl>moment>time,ant>beginning).@def)\n",
+    "obj(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,end(icl>moment>time,ant>beginning).@def)\n",
+    "obj(end(icl>moment>time,ant>beginning).@def,train(icl>public_transport>thing):01.@def)\n",
+    "mod(train(icl>public_transport>thing):02,static(icl>adj,equ>inactive))\n",
+    "mod(speed(icl>rate>thing):02,train(icl>public_transport>thing):02)\n",
+    "mod(profile(icl>chart>thing).@def,speed(icl>rate>thing):02)\n",
+    "aoj(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,profile(icl>chart>thing).@def)\n",
+    "man(high_degree_of(icl>adj,aoj>thing),more(icl>how))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to define certain locations (e.g. tunnels) where speed increase is related to the front of the train.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to define certain locations (e.g. tunnels) where speed increase is related to the front of the train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,define(icl>characterize>be,obj>uw,aoj>thing))\n",
+    "mod(location(icl>object>thing).@pl,certain(icl>adj,equ>certain))\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing),location(icl>object>thing).@pl)\n",
+    "plc(relate(icl>think>do,equ>associate,cob>thing,agt>volitional_thing,obj>thing).@present,location(icl>object>thing).@pl)\n",
+    "man:01(tunnel(icl>passageway>thing).@entry.@pl,\"e.g.\"(icl>how,equ>for_example))\n",
+    "mod(increase(icl>indefinite_quantity>thing,equ>addition).@topic,speed(icl>rate>thing))\n",
+    "obj(relate(icl>think>do,equ>associate,cob>thing,agt>volitional_thing,obj>thing).@present,increase(icl>indefinite_quantity>thing,equ>addition).@topic)\n",
+    "cob(relate(icl>think>do,equ>associate,cob>thing,agt>volitional_thing,obj>thing).@present,front(icl>proximity>thing,equ>presence).@def)\n",
+    "obj(front(icl>proximity>thing,equ>presence).@def,train(icl>public_transport>thing).@def)\n",
+    "cnt(location(icl>object>thing).@pl,:01.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The braking curves shall ensure that the train complies with its speed requirements.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The braking curves shall ensure that the train complies with its speed requirements. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,curve(icl>line>thing,ant>straight_line).@def.@pl)\n",
+    "aoj(ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing).@entry.@present.@promise,curve(icl>line>thing,ant>straight_line).@def.@pl)\n",
+    "agt:01(comply(icl>obey>do,agt>volitional_thing,obj>thing).@entry.@present,train(icl>public_transport>thing).@def)\n",
+    "pos:01(requirement(icl>duty>thing).@pl,it(icl>living_thing))\n",
+    "mod:01(requirement(icl>duty>thing).@pl,speed(icl>rate>thing))\n",
+    "obj:01(comply(icl>obey>do,agt>volitional_thing,obj>thing).@entry.@present,requirement(icl>duty>thing).@pl)\n",
+    "obj(ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing).@entry.@present.@promise,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Where failure to apply the full service brake is detected the emergency brake shall stop the train in rear of the danger point.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Where failure to apply the full service brake is detected the emergency brake shall stop the train in rear of the danger point. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(detect(icl>sight>do,equ>discover,agt>thing,obj>uw,plc>thing).@entry.@present,where(icl>how,plc<uw))\n",
+    "man(detect(icl>sight>do,equ>discover,agt>thing,obj>uw,plc>thing).@entry.@present,failure(icl>nonaccomplishment>thing).@topic)\n",
+    "mod:01(brake(icl>restraint>thing):01.@def,full(icl>adj,ant>empty))\n",
+    "mod:01(brake(icl>restraint>thing):01.@def,service(icl>work>action,agt>thing,obj>thing))\n",
+    "obj:01(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry,brake(icl>restraint>thing):01.@def)\n",
+    "mod:02(brake(icl>restraint>thing):02.@def,emergency(icl>crisis>thing))\n",
+    "agt:02(stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@present.@promise,brake(icl>restraint>thing):02.@def)\n",
+    "obj:02(stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@present.@promise,train(icl>public_transport>thing).@def)\n",
+    "plc:02(stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@present.@promise,rear(icl>formation>thing,ant>head))\n",
+    "mod:02(point(icl>component>thing).@def,danger(icl>condition>thing,ant>safety))\n",
+    "obj:02(rear(icl>formation>thing,ant>head),point(icl>component>thing).@def)\n",
+    "obj(failure(icl>nonaccomplishment>thing).@topic,:01)\n",
+    "obj(detect(icl>sight>do,equ>discover,agt>thing,obj>uw,plc>thing).@entry.@present,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The release speed shall be calculated on board, based on either:\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "safety distance and overlap, accuracy of odometry, deceleration performance of the train, etc. or given from the trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(distance(icl>spacing>thing).@entry,safety(icl>condition>thing,ant>danger))\n",
+    "and(overlap(icl>concurrence>thing),distance(icl>spacing>thing).@entry)\n",
+    "and(accuracy(icl>quality>thing,ant>inaccuracy),overlap(icl>concurrence>thing))\n",
+    "and:02(performance(icl>show>thing).@entry,odometry.@entry)\n",
+    "mod(:02.@_hn-scope,deceleration(icl>change>thing,ant>acceleration))\n",
+    "obj(or(icl>how,obj>uw,or<uw),performance(icl>show>thing).@entry)\n",
+    "and(:02.@_hn-scope,train(icl>public_transport>thing).@def)\n",
+    "obj:02(performance(icl>show>thing).@entry,etc(icl>how))\n",
+    "frm:01(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@entry,trackside.@def)\n",
+    "mod(overlap(icl>concurrence>thing),:01)\n",
+    "obj(accuracy(icl>quality>thing,ant>inaccuracy),:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The release speed given from the trackside shall take priority over the release speed calculated on board. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(speed(icl>rate>thing):01.@def,release(icl>merchandise>thing):01)\n",
+    "obj(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@state,speed(icl>rate>thing):01.@def)\n",
+    "agt(take(icl>read>do,agt>person,obj>thing).@entry.@present.@promise,speed(icl>rate>thing):01.@def)\n",
+    "frm(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@state,trackside.@def)\n",
+    "obj(take(icl>read>do,agt>person,obj>thing).@entry.@present.@promise,priority(icl>high_status>thing,equ>precedence))\n",
+    "mod(speed(icl>rate>thing):02.@def,release(icl>merchandise>thing):02)\n",
+    "obj(priority(icl>high_status>thing,equ>precedence),speed(icl>rate>thing):02.@def)\n",
+    "mod(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@past.@complete,speed(icl>rate>thing):02.@def)\n",
+    "man(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@past.@complete,on_board(icl>how,obj>thing))\n",
+    "obj(on_board(icl>how,obj>thing),which)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The release speed shall be calculated on board, based on either:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present.@promise,on_board(icl>how,obj>thing))\n",
+    "man(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing),on_board(icl>how,obj>thing))\n",
+    "mod(speed(icl>rate>thing).@def,release(icl>merchandise>thing))\n",
+    "obj(on_board(icl>how,obj>thing),speed(icl>rate>thing).@def)\n",
+    "and(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing),calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present.@promise)\n",
+    "cob(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing),either(icl>adj,equ>any))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The release speed shall be indicated on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The release speed shall be indicated on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(speed(icl>rate>thing).@def.@topic,release(icl>merchandise>thing))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,speed(icl>rate>thing).@def.@topic)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If the release speed is calculated on board it shall ensure that the train will stop before reaching the danger point\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the release speed is calculated on board it shall ensure that the train will stop before reaching the danger point. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(speed(icl>rate>thing).@def.@topic,release(icl>merchandise>thing))\n",
+    "obj:01(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@present,speed(icl>rate>thing).@def.@topic)\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on board)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,it(icl>thing))\n",
+    "aoj(ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing),it(icl>thing))\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing))\n",
+    "agt:02(stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@future,train(icl>public_transport>thing).@def)\n",
+    "tim:02(stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@future,before(icl>how,tim<uw,obj>thing))\n",
+    "mod:03(point(icl>component>thing).@def,danger(icl>condition>thing,ant>safety))\n",
+    "plt:03(reach(icl>arrive>do,plt>thing,agt>thing).@entry,point(icl>component>thing).@def)\n",
+    "con(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "obj(ensure(icl>guarantee>be,obj>thing,aoj>thing,ben>thing,cag>thing),:02)\n",
+    "obj:02(before(icl>how,tim<uw,obj>thing),:03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When the train is stationary or after a certain time (e.g. the time for \"route releasing\" of the overlap, the release speed calculation shall be based on the distance to the danger point (if calculated on-board). The condition for this change shall be defined for each target as infrastructure data.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When the train is stationary or after a certain time (e.g. the time for \"route releasing\" of the overlap, the release speed calculation shall be based on the distance to the danger point (if calculated on-board). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(stationary(icl>adj).@entry.@present,train(icl>public_transport>thing).@def)\n",
+    "tim(:01.@parenthesis,train(icl>public_transport>thing).@def)\n",
+    "or(time(icl>abstract_thing,equ>period).@indef,stationary(icl>adj).@entry.@present)\n",
+    "tim(stationary(icl>adj).@entry.@present,after(icl>subsequently>how))\n",
+    "mod(time(icl>abstract_thing,equ>period).@indef,certain(icl>adj,equ>certain))\n",
+    "mod:01(\"e.g.\"(icl>how,equ>for_example).@entry,time(icl>abstract_thing,equ>occasion))\n",
+    "obj:02(route(icl>dispatch>do,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry,release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing))\n",
+    "obj:01(:02.@double_quote,overlap(icl>concurrence>thing).@def)\n",
+    "mod:01(speed(icl>rate>thing),release(icl>merchandise>thing).@def)\n",
+    "mod:01(calculation(icl>procedure>thing).@topic,speed(icl>rate>thing))\n",
+    "obj:01(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@present.@promise,calculation(icl>procedure>thing).@topic)\n",
+    "pur:01(time(icl>abstract_thing,equ>occasion),base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@present.@promise)\n",
+    "cob:01(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@present.@promise,distance(icl>spacing>thing).@def)\n",
+    "mod:01(point(icl>component>thing).@def,danger(icl>condition>thing,ant>safety))\n",
+    "man:01(distance(icl>spacing>thing).@def,point(icl>component>thing).@def)\n",
+    "con:01(\"e.g.\"(icl>how,equ>for_example).@entry,calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism))\n",
+    "man:01(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism),on-board)\n",
+    "and:01(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@present.@promise,:02.@double_quote)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The condition for this change shall be defined for each target as infrastructure data. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present.@promise,condition(icl>state>abstract_thing,aoj>thing).@def.@topic)\n",
+    "mod(change(icl>difference>abstract_thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "man(condition(icl>state>abstract_thing,aoj>thing).@def.@topic,change(icl>difference>abstract_thing))\n",
+    "mod(target(icl>reference_point>thing),each(icl>quantity,per>thing))\n",
+    "pur(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present.@promise,target(icl>reference_point>thing))\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing).@entry.@present.@promise,as(icl>how,com>class,obj>thing,aoj<uw))\n",
+    "mod(data(icl>collection>thing),infrastructure(icl>structure>thing))\n",
+    "obj(as(icl>how,com>class,obj>thing,aoj<uw),data(icl>collection>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Each railway shall have the possibility of allowing a different release speed for every signal.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Each railway shall have the possibility of allowing a different release speed for every signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(railway(icl>line>thing),each(icl>quantity,per>thing))\n",
+    "aoj(have(icl>be,obj>thing,aoj>thing).@entry.@present.@promise,railway(icl>line>thing))\n",
+    "obj(have(icl>be,obj>thing,aoj>thing).@entry.@present.@promise,possibility(icl>perspective>abstract_thing,obj>uw).@def)\n",
+    "mod:01(release(icl>merchandise>thing).@indef,different(icl>adj,ant>same))\n",
+    "obj:01(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry,release(icl>merchandise>thing).@indef)\n",
+    "mod:02(signal(icl>communication>thing),every(icl>quantity,per>thing))\n",
+    "pur:02(speed(icl>travel>do,equ>rush,agt>volitional_thing).@entry,signal(icl>communication>thing))\n",
+    "obj(possibility(icl>perspective>abstract_thing,obj>uw).@def,:01)\n",
+    "pur(have(icl>be,obj>thing,aoj>thing).@entry.@present.@promise,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS trainborne equipment shall be able to determine the location of the entire train.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall be able to determine the location of the entire train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "aoj(determine(icl>cause>be,equ>shape,obj>thing,aoj>thing).@entry.@present.@ability.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "obj(determine(icl>cause>be,equ>shape,obj>thing,aoj>thing).@entry.@present.@ability.@promise,location(icl>object>thing).@def)\n",
+    "mod(train(icl>public_transport>thing).@def,entire(icl>adj,equ>integral))\n",
+    "obj(location(icl>object>thing).@def,train(icl>public_transport>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "On lines fitted with RBC, the ETCS trainborne equipment shall be able to transmit the location of the entire train to the RBC.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "On lines fitted with RBC, the ETCS trainborne equipment shall be able to transmit the location of the entire train to the RBC. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc:01(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@present.@ability.@promise,on(icl>how,com>surface,obj>concrete_thing,plc<uw).@entry)\n",
+    "obj:01(on(icl>how,com>surface,obj>concrete_thing,plc<uw).@entry,line(icl>formation>thing).@pl)\n",
+    "obj:01(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing).@state,line(icl>formation>thing).@pl)\n",
+    "gol:01(fit(icl>be,equ>go_in,obj>thing,aoj>thing,gol>thing).@state,rbc(icl>blood_cell>thing,equ>red_blood_cell):01)\n",
+    "mod:01(equipment(icl>instrumentality>thing).@def,etcs)\n",
+    "mod:01(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "aoj:01(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@present.@ability.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "obj:01(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@present.@ability.@promise,location(icl>object>thing).@def)\n",
+    "mod:01(train(icl>public_transport>thing).@def,entire(icl>adj,equ>integral))\n",
+    "obj:01(location(icl>object>thing).@def,train(icl>public_transport>thing).@def)\n",
+    "to:01(train(icl>public_transport>thing).@def,rbc(icl>blood_cell>thing,equ>red_blood_cell):02.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train location calculation shall take into account error of odometry.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train location calculation shall take into account error of odometry. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(location(icl>object>thing),train(icl>public_transport>thing))\n",
+    "mod(calculation(icl>procedure>thing).@def,location(icl>object>thing))\n",
+    "aoj(take(icl>require>be,obj>thing,aoj>thing,ben>person).@entry.@present.@promise,calculation(icl>procedure>thing).@def)\n",
+    "mod(error(icl>nonaccomplishment>thing,equ>mistake),account(icl>agreement(icl>abstract_thing)))\n",
+    "plt(take(icl>require>be,obj>thing,aoj>thing,ben>person).@entry.@present.@promise,error(icl>nonaccomplishment>thing,equ>mistake))\n",
+    "obj(error(icl>nonaccomplishment>thing,equ>mistake),odometry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Actual speed shall be indicated on the DMI\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Actual speed shall be indicated on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(speed(icl>rate>thing).@topic,actual(icl>adj,ant>potential))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,speed(icl>rate>thing).@topic)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "There shall be no discrepancy between the speed shown to the driver and the speed used for supervision of movement authorities and speed limits, function \n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "4.3.7.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(\"4.3\".@entry,\".7\")\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "There shall be no discrepancy between the speed shown to the driver and the speed used for supervision of movement authorities and speed limits, function. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(discrepancy(icl>difference>thing),no(icl>quantity,qua<thing))\n",
+    "aoj(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present.@promise,discrepancy(icl>difference>thing))\n",
+    "plc(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present.@promise,between(icl>how,obj>thing,plc<uw))\n",
+    "obj(between(icl>how,obj>thing,plc<uw),speed(icl>rate>thing):01)\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@state,speed(icl>rate>thing):01)\n",
+    "rec(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@state,to(icl>how,com>content,obj>thing))\n",
+    "and(speed(icl>rate>thing):02,driver(icl>operator>thing,ant>nondriver))\n",
+    "obj(to(icl>how,com>content,obj>thing),speed(icl>rate>thing):02)\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,speed(icl>rate>thing):02)\n",
+    "pur(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,supervision(icl>management>thing))\n",
+    "obj(supervision(icl>management>thing),of(icl>how,com>quality,obj>thing))\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@pl,movement(icl>happening>thing))\n",
+    "and(limit(icl>extent>thing).@pl,authority(icl>abstract_thing,obj>uw).@pl)\n",
+    "mod(limit(icl>extent>thing).@pl,speed(icl>rate>thing):03)\n",
+    "obj(of(icl>how,com>quality,obj>thing),limit(icl>extent>thing).@pl)\n",
+    "cnt(authority(icl>abstract_thing,obj>uw).@pl,function(icl>mathematical_relation>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The indication provided shall enable the driver to drive at the permitted speed without receiving a warning and without intervention of ETCS.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The indication provided shall enable the driver to drive at the permitted speed without receiving a warning and without intervention of ETCS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@state,indication(icl>communication>thing).@def)\n",
+    "agt(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry.@present.@promise,indication(icl>communication>thing).@def)\n",
+    "obj(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "gol(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry.@present.@promise,drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing))\n",
+    "tim(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing),speed(icl>rate>thing).@def)\n",
+    "obj(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@state,speed(icl>rate>thing).@def)\n",
+    "mod(speed(icl>rate>thing).@def,without(icl>how,ant>with,com>physical,obj>thing):01)\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing):01,receive(icl>acquire>do,src>thing,obj>thing))\n",
+    "and(without(icl>how,ant>with,com>physical,obj>thing):02,warn(icl>notify_of_danger>do,cob>uw,agt>person,obj>person).@indef)\n",
+    "obj(receive(icl>acquire>do,src>thing,obj>thing),intervention(icl>engagement>thing))\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing):02,intervention(icl>engagement>thing))\n",
+    "obj(intervention(icl>engagement>thing),etcs)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall know the distance to the next point defining the indicated braking curve and the permitted speed allowed. This shall be shown to the driver in a way that is understandable and logical.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall know the distance to the next point defining the indicated braking curve and the permitted speed allowed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "aoj(know(icl>be,equ>cognise,obj>uw,cao>thing,aoj>volitional_thing),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "and(:01,promise(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,know(icl>be,equ>cognise,obj>uw,cao>thing,aoj>volitional_thing))\n",
+    "obj(know(icl>be,equ>cognise,obj>uw,cao>thing,aoj>volitional_thing),distance(icl>spacing>thing).@def)\n",
+    "mod(point(icl>component>thing).@def,next(icl>adj,equ>adjacent))\n",
+    "man(distance(icl>spacing>thing).@def,point(icl>component>thing).@def)\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing).@progress,point(icl>component>thing).@def)\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@progress,curve(icl>line>thing,ant>straight_line).@def)\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@state,curve(icl>line>thing,ant>straight_line).@def)\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,curve(icl>line>thing,ant>straight_line).@def)\n",
+    "agt:01(speed(icl>travel>do,equ>rush,agt>volitional_thing).@entry.@present,permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@def)\n",
+    "aoj:01(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing),permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@def)\n",
+    "man:01(speed(icl>travel>do,equ>rush,agt>volitional_thing).@entry.@present,allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This shall be shown to the driver in a way that is understandable and logical. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,this(icl>thing,equ>it,equ>that).@topic)\n",
+    "rec(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "plc(driver(icl>operator>thing,ant>nondriver).@def,way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef)\n",
+    "mod(that(icl>thing,equ>it,equ>this),way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef)\n",
+    "aoj(understandable(icl>adj,equ>apprehensible).@present,that(icl>thing,equ>it,equ>this))\n",
+    "and(logical(icl>adj,ant>illogical),understandable(icl>adj,equ>apprehensible).@present)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Visual and acoustic warnings to the driver about possible intervention from ETCS shall be given to enable the driver to react and avoid intervention.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Visual and acoustic warnings to the driver about possible intervention from ETCS shall be given to enable the driver to react and avoid intervention. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(acoustic(icl>adj,com>acoustics),visual(icl>adj,equ>ocular,com>sight))\n",
+    "mod(warning(icl>informing>thing).@pl.@topic,acoustic(icl>adj,com>acoustics))\n",
+    "obj(give(icl>do,equ>hand_over,agt>living_thing,obj>concrete_thing,rec>person).@entry.@present.@promise,warning(icl>informing>thing).@pl.@topic)\n",
+    "obj(warning(icl>informing>thing).@pl.@topic,driver(icl>operator>thing,ant>nondriver):01.@def)\n",
+    "mod(intervention(icl>engagement>thing):01,possible(icl>adj,ant>impossible))\n",
+    "man(warning(icl>informing>thing).@pl.@topic,intervention(icl>engagement>thing):01)\n",
+    "frm(intervention(icl>engagement>thing):01,etcs)\n",
+    "obj:01(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry,driver(icl>operator>thing,ant>nondriver):02.@def)\n",
+    "and(:02,react(icl>change>be,aoj>matter))\n",
+    "obj:02(avoid(icl>prevent>do,agt>thing,obj>abstract_thing).@entry,intervention(icl>engagement>thing):02)\n",
+    "pur(give(icl>do,equ>hand_over,agt>living_thing,obj>concrete_thing,rec>person).@entry.@present.@promise,:01)\n",
+    "gol:01(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall have the possibility to select the language, this does not concern non pre-defined texts sent from the trackside.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall have the possibility to select the language, this does not concern non pre-defined texts sent from the trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj:02(promise(icl>modal>be,obj>uw,aoj>thing).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "aoj:02(have(icl>be,obj>thing,aoj>thing),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "and:02(concern(icl>touch>be,obj>thing,aoj>thing).@not.@present,promise(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "obj:02(promise(icl>modal>be,obj>uw,aoj>thing).@entry,have(icl>be,obj>thing,aoj>thing))\n",
+    "obj:02(have(icl>be,obj>thing,aoj>thing),possibility(icl>perspective>abstract_thing,obj>uw).@def)\n",
+    "obj:01(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry,language(icl>communication>thing).@def)\n",
+    "aoj:02(concern(icl>touch>be,obj>thing,aoj>thing).@not.@present,this(icl>thing,equ>it,equ>that))\n",
+    "man:02(predefine.@state,non)\n",
+    "obj:02(concern(icl>touch>be,obj>thing,aoj>thing).@not.@present,text(icl>passage>thing).@entry.@pl)\n",
+    "obj:02(predefine.@state,text(icl>passage>thing).@entry.@pl)\n",
+    "obj:02(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing).@state,text(icl>passage>thing).@entry.@pl)\n",
+    "plf:02(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing).@state,trackside.@def)\n",
+    "obj:02(possibility(icl>perspective>abstract_thing,obj>uw).@def,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A train shall be supervised to its static and dynamic train speed profiles.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A train shall be supervised to its static and dynamic train speed profiles. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:01(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry,train(icl>public_transport>thing):01.@indef.@topic)\n",
+    "and(:02,promise(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "pos:01(static(icl>adj,equ>inactive),it(icl>living_thing))\n",
+    "to:01(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry,static(icl>adj,equ>inactive))\n",
+    "mod:02(speed(icl>rate>thing),dynamic(icl>adj,ant>undynamic))\n",
+    "mod:02(speed(icl>rate>thing),train(icl>public_transport>thing):02)\n",
+    "agt:02(profile(icl>write_about>do,agt>thing,obj>thing).@entry.@present,speed(icl>rate>thing))\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Within the braking curve area, a warning shall be given to the driver to enable him to react and avoid intervention from ETCS equipment at least 5 sec. before the intervention.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Within the braking curve area, a warning shall be given to the driver to enable him to react and avoid intervention from ETCS equipment at least 5 sec. before the intervention. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(within(icl>how,com>limit,obj>thing,scn<abstract_thing).@entry,curve(icl>line>thing,ant>straight_line))\n",
+    "agt:02(warn(icl>notify_of_danger>do,cob>uw,agt>person,obj>person).@indef.@progress,area(icl>extent>abstract_thing,obj>thing).@entry)\n",
+    "cob:02(warn(icl>notify_of_danger>do,cob>uw,agt>person,obj>person).@indef.@progress,give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@present.@promise)\n",
+    "ben:02(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "pur:02(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@present.@promise,enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing))\n",
+    "obj:02(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing),he(icl>person))\n",
+    "and:02(avoid(icl>prevent>do,agt>thing,obj>abstract_thing),react(icl>change>be,aoj>matter))\n",
+    "gol:02(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing),avoid(icl>prevent>do,agt>thing,obj>abstract_thing))\n",
+    "obj:02(avoid(icl>prevent>do,agt>thing,obj>abstract_thing),intervention(icl>engagement>thing):01)\n",
+    "mod:02(equipment(icl>instrumentality>thing),etcs)\n",
+    "frm:02(intervention(icl>engagement>thing):01,equipment(icl>instrumentality>thing))\n",
+    "man:01(5,at_least(icl>how))\n",
+    "obj:01(brake(icl>stop>do,agt>thing,obj>thing).@entry.@def,5)\n",
+    "man:01(before(icl>how,tim<uw,obj>thing),second(icl>time_unit>thing))\n",
+    "tim:01(brake(icl>stop>do,agt>thing,obj>thing).@entry.@def,before(icl>how,tim<uw,obj>thing))\n",
+    "obj:01(before(icl>how,tim<uw,obj>thing),intervention(icl>engagement>thing):02.@def)\n",
+    "obj(within(icl>how,com>limit,obj>thing,scn<abstract_thing).@entry,:01)\n",
+    "fictit(within(icl>how,com>limit,obj>thing,scn<abstract_thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If the train or the shunting movement exceeds the permitted ceiling speed by a certain harmonised margin, the trainborne equipment shall execute a brake intervention until the actual speed does not exceed permitted speed; then the driver shall be able to release the brake\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the train or the shunting movement exceeds the permitted ceiling speed by a certain harmonised margin, the trainborne equipment shall execute a brake intervention until the actual speed does not exceed permitted speed; then the driver shall be able to release the brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "con(or(icl>how,obj>uw,or<uw).@entry,train(icl>public_transport>thing).@def)\n",
+    "agt:02(shunt(icl>transfer>do,agt>thing,obj>thing).@progress,movement(icl>happening>thing).@def)\n",
+    "aoj:02(exceed(icl>go_beyond>be,obj>thing,aoj>thing,scn>thing,val>thing):01.@present,movement(icl>happening>thing).@def)\n",
+    "and:02(execute(icl>perform>do,agt>person,obj>thing).@present.@promise,exceed(icl>go_beyond>be,obj>thing,aoj>thing,scn>thing,val>thing):01.@present)\n",
+    "mod(or(icl>how,obj>uw,or<uw).@entry,permit(icl>accept>do,agt>thing,obj>thing,rec>thing):01)\n",
+    "obj:01(ceil.@entry,speed(icl>rate>thing):01)\n",
+    "mod(margin(icl>boundary>thing).@indef,certain(icl>adj,equ>certain))\n",
+    "agt(permit(icl>accept>do,agt>thing,obj>thing,rec>thing):01,margin(icl>boundary>thing).@indef)\n",
+    "obj(harmonise(icl>adjust>do,cob>thing,agt>volitional_thing,obj>thing).@state,margin(icl>boundary>thing).@indef)\n",
+    "mod:02(equipment(icl>instrumentality>thing),trainborne.@def)\n",
+    "agt:02(execute(icl>perform>do,agt>person,obj>thing).@present.@promise,equipment(icl>instrumentality>thing))\n",
+    "mod:02(intervention(icl>engagement>thing).@indef,brake(icl>restraint>thing):01)\n",
+    "obj:02(execute(icl>perform>do,agt>person,obj>thing).@present.@promise,intervention(icl>engagement>thing).@indef)\n",
+    "mod:02(speed(icl>rate>thing):02.@def,actual(icl>adj,ant>potential))\n",
+    "aoj:02(exceed(icl>go_beyond>be,obj>thing,aoj>thing,scn>thing,val>thing):02.@not.@present,speed(icl>rate>thing):02.@def)\n",
+    "and:02(promise(icl>modal>be,obj>uw,aoj>thing),exceed(icl>go_beyond>be,obj>thing,aoj>thing,scn>thing,val>thing):02.@not.@present)\n",
+    "obj:02(exceed(icl>go_beyond>be,obj>thing,aoj>thing,scn>thing,val>thing):02.@not.@present,speed(icl>rate>thing):03.@entry)\n",
+    "obj:02(permit(icl>accept>do,agt>thing,obj>thing,rec>thing):02.@state,speed(icl>rate>thing):03.@entry)\n",
+    "man:02(promise(icl>modal>be,obj>uw,aoj>thing),then(icl>how,equ>in_that_case))\n",
+    "aoj:02(promise(icl>modal>be,obj>uw,aoj>thing),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj:02(promise(icl>modal>be,obj>uw,aoj>thing),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "aoj(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@ability,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "tmt:02(execute(icl>perform>do,agt>person,obj>thing).@present.@promise,promise(icl>modal>be,obj>uw,aoj>thing))\n",
+    "obj(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@ability,brake(icl>restraint>thing):02.@def)\n",
+    "obj(permit(icl>accept>do,agt>thing,obj>thing,rec>thing):01,:01)\n",
+    "obj(or(icl>how,obj>uw,or<uw).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall be able to release an ETCS emergency brake application when stationary.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall be able to release an ETCS emergency brake application when stationary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry.@present.@ability.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(emergency(icl>crisis>thing),etcs)\n",
+    "mod(brake(icl>restraint>thing),emergency(icl>crisis>thing))\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw).@indef,brake(icl>restraint>thing))\n",
+    "obj(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry.@present.@ability.@promise,application(icl>information,equ>request,agt>thing,obj>uw).@indef)\n",
+    "con(application(icl>information,equ>request,agt>thing,obj>uw).@indef,when(icl>how,com>condition,obj>uw,con<uw))\n",
+    "obj(when(icl>how,com>condition,obj>uw,con<uw),stationary(icl>adj))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If decided by a national value, the driver may release the ETCS emergency brake when the actual speed is below the permitted speed.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If decided by a national value, the driver may release the ETCS emergency brake when the actual speed is below the permitted speed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "con:01(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@present.@grant,decide(icl>choose>do,agt>volitional_thing,obj>uw,scn>thing).@entry)\n",
+    "mod:01(value(icl>property,obj>thing).@indef,national(icl>adj,ant>international))\n",
+    "agt:01(decide(icl>choose>do,agt>volitional_thing,obj>uw,scn>thing).@entry,value(icl>property,obj>thing).@indef)\n",
+    "agt:01(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@present.@grant,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod:01(emergency(icl>crisis>thing),etcs)\n",
+    "mod:01(brake(icl>restraint>thing).@def,emergency(icl>crisis>thing))\n",
+    "obj:01(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@present.@grant,brake(icl>restraint>thing).@def)\n",
+    "mod:02(speed(icl>rate>thing):01.@def,actual(icl>adj,ant>potential))\n",
+    "aoj:02(be(icl>be,equ>be_located,aoj>thing,plc>uw).@present,speed(icl>rate>thing):01.@def)\n",
+    "plc:02(be(icl>be,equ>be_located,aoj>thing,plc>uw).@present,below(icl>how,equ>lower,obj>thing,plc<uw))\n",
+    "obj:02(below(icl>how,equ>lower,obj>thing,plc<uw),speed(icl>rate>thing):02.@entry.@def)\n",
+    "obj:02(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@state,speed(icl>rate>thing):02.@entry.@def)\n",
+    "tim:01(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@present.@grant,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "To protect a traction unit from roll away and unwanted reverse movements the trainborne equipment shall monitor the direction of movement in relation to the permitted direction.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "To protect a traction unit from roll away and unwanted reverse movements the trainborne equipment shall monitor the direction of movement in relation to the permitted direction. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(unit(icl>measure>abstract_thing,aoj>uw).@indef,traction(icl>pull>thing))\n",
+    "obj:01(protect(icl>do,equ>defend,rsn>thing,agt>thing,obj>thing,met>thing).@entry,unit(icl>measure>abstract_thing,aoj>uw).@indef)\n",
+    "and:04(movement(icl>happening>thing):01.@entry.@pl,roll(icl>rotation>thing,equ>axial_rotation).@entry)\n",
+    "mod(:04.@_hn-scope,unwanted(icl>adj,ant>wanted))\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,equipment(icl>instrumentality>thing).@def)\n",
+    "agt(monitor(icl>supervise>do,agt>thing,obj>thing),equipment(icl>instrumentality>thing).@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,monitor(icl>supervise>do,agt>thing,obj>thing))\n",
+    "obj(monitor(icl>supervise>do,agt>thing,obj>thing),direction(icl>path>thing):01.@def)\n",
+    "obj(direction(icl>path>thing):01.@def,movement(icl>happening>thing):02)\n",
+    "mod(movement(icl>happening>thing):02,in_relation_to(icl>how,com>compare,obj>thing))\n",
+    "obj(in_relation_to(icl>how,com>compare,obj>thing),direction(icl>path>thing):02.@def)\n",
+    "obj(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@state,direction(icl>path>thing):02.@def)\n",
+    "mod(roll(icl>rotation>thing,equ>axial_rotation).@entry,:01)\n",
+    "pur(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "rsn(protect(icl>do,equ>defend,rsn>thing,agt>thing,obj>thing,met>thing).@entry,:04.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The trainborne equipment shall apply the emergency brake after a distance, defined by a national value, is travelled by the train.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The trainborne equipment shall apply the emergency brake after a distance, defined by a national value, is travelled by the train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "agt(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "mod(brake(icl>restraint>thing).@def,emergency(icl>crisis>thing))\n",
+    "obj(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry.@present.@promise,brake(icl>restraint>thing).@def)\n",
+    "tim(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry.@present.@promise,after(icl>how,equ>later,tim<uw,obj>uw))\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@state,distance(icl>spacing>thing).@indef.@topic)\n",
+    "plf(travel(icl>move>occur,plt>thing,plf>thing,obj>thing).@present,distance(icl>spacing>thing).@indef.@topic)\n",
+    "mod(value(icl>property,obj>thing).@indef,national(icl>adj,ant>international))\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing).@state,value(icl>property,obj>thing).@indef)\n",
+    "obj(after(icl>how,equ>later,tim<uw,obj>uw),travel(icl>move>occur,plt>thing,plf>thing,obj>thing).@present)\n",
+    "agt(travel(icl>move>occur,plt>thing,plf>thing,obj>thing).@present,train(icl>public_transport>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The roll away/reverse movement intervention shall be indicated on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The roll away/reverse movement intervention shall be indicated on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(movement(icl>happening>thing),roll(icl>rotation>thing,equ>axial_rotation))\n",
+    "or(reverse(icl>adj,equ>inverse),away(icl>adj,equ>away))\n",
+    "mod(movement(icl>happening>thing),reverse(icl>adj,equ>inverse))\n",
+    "mod(intervention(icl>engagement>thing).@def.@topic,movement(icl>happening>thing))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,intervention(icl>engagement>thing).@def.@topic)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When the traction unit has come to a standstill, the driver shall be able to release the emergency brake.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When the traction unit has come to a standstill, the driver shall be able to release the emergency brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@def,traction(icl>pull>thing))\n",
+    "agt(come(icl>move>do,plt>place,agt>person).@present.@complete,unit(icl>measure>abstract_thing,aoj>uw).@def)\n",
+    "tim(brake(icl>stop>occur,obj>thing).@entry.@imperative,come(icl>move>do,plt>place,agt>person).@present.@complete)\n",
+    "plt(come(icl>move>do,plt>place,agt>person).@present.@complete,to(icl>how,com>reaction,obj>thing))\n",
+    "obj(to(icl>how,com>reaction,obj>thing),standstill(icl>situation>thing,equ>deadlock).@indef)\n",
+    "man(come(icl>move>do,plt>place,agt>person).@present.@complete,driver(icl>operator>thing,ant>nondriver).@def.@parenth)\n",
+    "aoj(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@present.@ability.@promise,driver(icl>operator>thing,ant>nondriver).@def.@parenth)\n",
+    "obj(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@present.@ability.@promise,emergency(icl>crisis>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "After releasing the emergency brake ETCS will provide the supervision appertaining when roll away protection was initiated\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "After releasing the emergency brake ETCS will provide the supervision appertaining when roll away protection was initiated. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(provide(icl>equip>do,cob>thing,obj>thing).@entry.@future,after(icl>how,tim<uw,obj>uw))\n",
+    "obj:01(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry,emergency(icl>crisis>thing).@def)\n",
+    "mod(etcs,brake(icl>restraint>thing))\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@entry.@future,etcs)\n",
+    "aoj:02(appertain(icl>dwell>be,equ>pertain,obj>thing,aoj>thing).@progress,supervision(icl>management>thing).@entry.@def)\n",
+    "mod:02(away(icl>adj,equ>away),roll(icl>rotation>thing,equ>axial_rotation))\n",
+    "mod:02(protection(icl>action,agt>thing,obj>thing,cag>thing).@topic,away(icl>adj,equ>away))\n",
+    "obj:02(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@past,protection(icl>action,agt>thing,obj>thing,cag>thing).@topic)\n",
+    "tim:02(appertain(icl>dwell>be,equ>pertain,obj>thing,aoj>thing).@progress,initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@past)\n",
+    "obj(after(icl>how,tim<uw,obj>uw),:01)\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@future,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When using more than one traction unit this function shall be disabled in all but the leading traction unit.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When using more than one traction unit this function shall be disabled in all but the leading traction unit. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man:01(promise(icl>modal>be,obj>uw,aoj>thing).@entry,use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw))\n",
+    "obj:01(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw),more(icl>how))\n",
+    "qua:01(unit(icl>measure>abstract_thing,aoj>uw):01,one(icl>digit>thing))\n",
+    "mod:01(unit(icl>measure>abstract_thing,aoj>uw):01,traction(icl>pull>thing):01)\n",
+    "bas:01(more(icl>how),unit(icl>measure>abstract_thing,aoj>uw):01)\n",
+    "mod:02(function(icl>mathematical_relation>thing).@topic,this(icl>determiner>adj,mod<concrete_thing))\n",
+    "obj:02(disable(icl>change>do,agt>thing,obj>thing),function(icl>mathematical_relation>thing).@topic)\n",
+    "plc:02(disable(icl>change>do,agt>thing,obj>thing),all(icl>quantity,ant>some,per>thing))\n",
+    "man:02(all(icl>quantity,ant>some,per>thing),but(icl>how,equ>except_for,obj>uw,man<uw))\n",
+    "mod:02(unit(icl>measure>abstract_thing,aoj>uw):02.@entry.@def,traction(icl>pull>thing):02)\n",
+    "obj:02(but(icl>how,equ>except_for,obj>uw,man<uw),unit(icl>measure>abstract_thing,aoj>uw):02.@entry.@def)\n",
+    "agt:02(lead(icl>induce>do,agt>thing,obj>volitional_thing,gol>uw).@progress,unit(icl>measure>abstract_thing,aoj>uw):02.@entry.@def)\n",
+    "obj(when(icl>how,tim<uw,obj>uw).@entry,:01)\n",
+    "obj:01(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "All data entered, received or indicated to the driver shall be recorded onboard. All data shall be related to UTC (Universal Time Corrected) and a reference point.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "All data entered, received or indicated to the driver shall be recorded onboard. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "qua(data(icl>collection>thing).@pl,all(icl>quantity,ant>some,per>thing))\n",
+    "agt(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@past,data(icl>collection>thing).@pl)\n",
+    "agt(receive(icl>acquire>do,src>thing,obj>thing).@past,data(icl>collection>thing).@pl)\n",
+    "or(receive(icl>acquire>do,src>thing,obj>thing).@past,enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry.@past)\n",
+    "or(:01,receive(icl>acquire>do,src>thing,obj>thing).@past)\n",
+    "agt:01(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@past,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj:02(record(icl>write>do,plt>uw,obj>uw).@entry.@present.@promise,onboard.@topic)\n",
+    "obj:01(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@past,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "All data shall be related to UTC (Universal Time Corrected) and a reference point. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "qua(data(icl>collection>thing).@pl.@topic,all(icl>quantity,ant>some,per>thing))\n",
+    "obj(relate(icl>think>do,equ>associate,cob>thing,agt>volitional_thing,obj>thing).@entry.@present.@promise,data(icl>collection>thing).@pl.@topic)\n",
+    "and(point(icl>component>thing).@indef,utc)\n",
+    "mod:01(time(icl>abstract_thing,equ>period).@maiuscul,universal(icl>adj,equ>cosmopolitan).@maiuscul)\n",
+    "obj:01(correct(icl>change_by_reversal>do,agt>volitional_thing,obj>thing).@entry.@state.@maiuscul,time(icl>abstract_thing,equ>period).@maiuscul)\n",
+    "mod(point(icl>component>thing).@indef,reference(icl>remark>thing,equ>mention))\n",
+    "cob(relate(icl>think>do,equ>associate,cob>thing,agt>volitional_thing,obj>thing).@entry.@present.@promise,point(icl>component>thing).@indef)\n",
+    "cnt(utc,:01.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Information shall be recorded to an accuracy which enables a clear view of the functioning of ETCS and way the traction unit has been driven.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Information shall be recorded to an accuracy which enables a clear view of the functioning of ETCS and way the traction unit has been driven. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(record(icl>write>do,plt>uw,obj>uw).@entry.@present.@promise,information(icl>message>thing).@topic)\n",
+    "to(record(icl>write>do,plt>uw,obj>uw).@entry.@present.@promise,accuracy(icl>quality>thing,ant>inaccuracy).@indef)\n",
+    "agt(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@present,accuracy(icl>quality>thing,ant>inaccuracy).@indef)\n",
+    "mod(view(icl>abstract_thing,equ>scenery).@indef,clear(icl>adj,ant>unclear))\n",
+    "obj(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@present,view(icl>abstract_thing,equ>scenery).@indef)\n",
+    "obj(view(icl>abstract_thing,equ>scenery).@indef,function(icl>do,equ>operate,agt>thing).@def)\n",
+    "and(way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing),etcs)\n",
+    "obj(function(icl>do,equ>operate,agt>thing).@def,way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing))\n",
+    "plt(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@present.@complete,way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@def.@topic,traction(icl>pull>thing))\n",
+    "obj(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@present.@complete,unit(icl>measure>abstract_thing,aoj>uw).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Standardised output interfaces shall enable transmission of information recorded to other media for investigation\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Standardised output interfaces shall enable transmission of information recorded to other media for investigation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(interface(icl>surface>thing).@pl,output(icl>produce>do,agt>thing,obj>thing))\n",
+    "obj(standardize(icl>regulate>do,agt>thing,obj>thing).@state,interface(icl>surface>thing).@pl)\n",
+    "agt(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry.@present.@promise,interface(icl>surface>thing).@pl)\n",
+    "obj(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry.@present.@promise,transmission(icl>sending>thing))\n",
+    "obj(transmission(icl>sending>thing),information(icl>message>thing))\n",
+    "obj(record(icl>write>do,plt>uw,obj>uw).@state,information(icl>message>thing))\n",
+    "mod(medium(icl>instrumentality>thing).@pl,other(icl>adj,equ>different))\n",
+    "plt(record(icl>write>do,plt>uw,obj>uw).@state,medium(icl>instrumentality>thing).@pl)\n",
+    "pur(medium(icl>instrumentality>thing).@pl,investigation(icl>inquiry>thing,equ>probe))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The retention period for the recorded data will be different and two levels are foreseen:\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Data to enable investigation of accidents need only be stored for at least 24 hours, and shall be very detailed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@need,data(icl>collection>thing).@topic)\n",
+    "obj:01(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry,investigation(icl>inquiry>thing,equ>probe))\n",
+    "obj:01(investigation(icl>inquiry>thing,equ>probe),accident(icl>mishap>thing).@pl)\n",
+    "man(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@need,only(icl>how,com>result))\n",
+    "man(detail(icl>elaborate>do,agt>volitional_thing,obj>thing,rec>thing).@present.@promise,only(icl>how,com>result))\n",
+    "and(detail(icl>elaborate>do,agt>volitional_thing,obj>thing,rec>thing).@present.@promise,store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@need)\n",
+    "man(24,at_least(icl>how))\n",
+    "qua(hour(icl>time_period>thing).@pl,24)\n",
+    "dur(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@need,hour(icl>time_period>thing).@pl)\n",
+    "man(detail(icl>elaborate>do,agt>volitional_thing,obj>thing,rec>thing).@present.@promise,very(icl>how,equ>extremely))\n",
+    "pur(data(icl>collection>thing).@topic,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Operational data to enable assessment of driver performance shall be stored for at least one week.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@topic,operational(icl>adj,com>operation))\n",
+    "obj(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@promise,data(icl>collection>thing).@topic)\n",
+    "obj:01(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@entry,assessment(icl>classification>thing,equ>appraisal))\n",
+    "mod:01(performance(icl>show>thing),driver(icl>operator>thing,ant>nondriver))\n",
+    "obj:01(assessment(icl>classification>thing,equ>appraisal),performance(icl>show>thing))\n",
+    "man(one(icl>digit>thing),at_least(icl>how))\n",
+    "qua(week(icl>time,equ>calendar_week),one(icl>digit>thing))\n",
+    "dur(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@entry.@present.@promise,week(icl>time,equ>calendar_week))\n",
+    "pur(data(icl>collection>thing).@topic,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The retention period for the recorded data will be different and two levels are foreseen:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(period(icl>fundamental_quantity>thing,equ>time_period).@def,retention(icl>possession>thing))\n",
+    "aoj(different(icl>adj,ant>same).@entry.@future,period(icl>fundamental_quantity>thing,equ>time_period).@def)\n",
+    "pur(period(icl>fundamental_quantity>thing,equ>time_period).@def,data(icl>collection>thing).@def)\n",
+    "obj(record(icl>write>do,plt>uw,obj>uw).@state,data(icl>collection>thing).@def)\n",
+    "and(:01,different(icl>adj,ant>same).@entry.@future)\n",
+    "qua:01(level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@pl.@topic,two(icl>digit>thing))\n",
+    "obj:01(foresee(icl>know>do,equ>anticipate,agt>thing,obj>thing).@entry.@pl.@present,level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@pl.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The following information shall be recorded:\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "any transition of Level and of operational status, the driver's confirmation of transition to shunting, train supervision data and information received from national train control systems, actual speed, full service brake intervention, emergency brake intervention, applying the train trip function, selection of the override control, override of the route suitability function, isolation of on board ETCS equipmen, data entered, recieved or indicated to the driver.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(transition(icl>change_of_state>thing,equ>passage):01,any(icl>adj))\n",
+    "agt(trip(icl>caper>do,plt>thing,plf>thing,agt>living_thing).@entry.@present,transition(icl>change_of_state>thing,equ>passage):01)\n",
+    "and(status(icl>state>thing),level(icl>property>abstract_thing,obj>quantity,aoj>thing,scn>uw).@maiuscul)\n",
+    "mod(status(icl>state>thing),operational(icl>adj,com>operation))\n",
+    "and(confirmation(icl>proof>thing),status(icl>state>thing))\n",
+    "obj(transition(icl>change_of_state>thing,equ>passage):01,confirmation(icl>proof>thing))\n",
+    "agt(confirmation(icl>proof>thing),driver(icl>operator>thing,ant>nondriver):01.@def)\n",
+    "obj(confirmation(icl>proof>thing),transition(icl>change_of_state>thing,equ>passage):02)\n",
+    "mod(supervision(icl>management>thing),train(icl>public_transport>thing):01)\n",
+    "mod(data(icl>collection>thing):01,supervision(icl>management>thing))\n",
+    "and(information(icl>message>thing),data(icl>collection>thing):01)\n",
+    "man(transition(icl>change_of_state>thing,equ>passage):02,information(icl>message>thing))\n",
+    "obj(receive(icl>acquire>do,src>thing,obj>thing).@past.@complete,information(icl>message>thing))\n",
+    "mod(service(icl>work>action,agt>thing,obj>thing),national(icl>adj,ant>international))\n",
+    "mod:02(control(icl>power>thing):01.@entry,train(icl>public_transport>thing):02)\n",
+    "and:04(speed(icl>rate>thing).@entry,system(icl>group>thing).@entry.@pl)\n",
+    "mod(:04.@_hn-scope,actual(icl>adj,ant>potential))\n",
+    "mod(service(icl>work>action,agt>thing,obj>thing),full(icl>increase>occur,equ>wax,src>thing,obj>thing).@present)\n",
+    "mod(brake(icl>restraint>thing):01,service(icl>work>action,agt>thing,obj>thing))\n",
+    "mod(intervention(icl>engagement>thing):01,brake(icl>restraint>thing):01)\n",
+    "and(intervention(icl>engagement>thing):02,intervention(icl>engagement>thing):01)\n",
+    "mod(brake(icl>restraint>thing):02,emergency(icl>crisis>thing))\n",
+    "mod(intervention(icl>engagement>thing):02,brake(icl>restraint>thing):02)\n",
+    "and(:03,intervention(icl>engagement>thing):02)\n",
+    "obj:03(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry,train(icl>public_transport>thing):03.@def)\n",
+    "or(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@past,trip(icl>caper>do,plt>thing,plf>thing,agt>living_thing).@entry.@present)\n",
+    "plf(trip(icl>caper>do,plt>thing,plf>thing,agt>living_thing).@entry.@present,function(icl>mathematical_relation>thing):01)\n",
+    "plf(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@past,function(icl>mathematical_relation>thing):01)\n",
+    "and(override(icl>device>thing):02,selection(icl>action,agt>thing,obj>thing))\n",
+    "mod(control(icl>power>thing):02,override(icl>device>thing):01.@def)\n",
+    "obj(selection(icl>action,agt>thing,obj>thing),control(icl>power>thing):02)\n",
+    "obj(trip(icl>caper>do,plt>thing,plf>thing,agt>living_thing).@entry.@present,override(icl>device>thing):02)\n",
+    "mod:06(suitability(icl>quality>thing,ant>unsuitability).@def,route(icl>line>thing,equ>path))\n",
+    "mod:06(function(icl>mathematical_relation>thing):02.@entry,suitability(icl>quality>thing,ant>unsuitability).@def)\n",
+    "and:06(isolation(icl>separation>thing).@entry,function(icl>mathematical_relation>thing):02.@entry)\n",
+    "obj:06(isolation(icl>separation>thing).@entry,of(icl>how,com>quality,obj>thing))\n",
+    "mod(function(icl>mathematical_relation>thing):02.@entry,on_board(icl>how,obj>thing))\n",
+    "mod(equipmen,etcs)\n",
+    "and(data(icl>collection>thing):02,equipmen)\n",
+    "and(recieved,data(icl>collection>thing):02)\n",
+    "obj(on_board(icl>how,obj>thing),recieved)\n",
+    "obj(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@state,recieved)\n",
+    "agt(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@past,driver(icl>operator>thing,ant>nondriver):02.@def)\n",
+    "and(data(icl>collection>thing):01,:01)\n",
+    "mod:04(system(icl>group>thing).@entry.@pl,:02)\n",
+    "obj:01(shunt(icl>transfer>do,agt>thing,obj>thing).@entry,:03)\n",
+    "obj(full(icl>increase>occur,equ>wax,src>thing,obj>thing).@present,:04.@_hn-scope)\n",
+    "obj(override(icl>device>thing):02,:06.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The following information shall be recorded:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(information(icl>message>thing).@def.@topic,following(icl>adj,ant>leading))\n",
+    "obj(record(icl>write>do,plt>uw,obj>uw).@entry.@present.@promise,information(icl>message>thing).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to use multiple traction units without isolating the ETCS trainborne equipment on traction unit(s) with an in-operative cab.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to use multiple traction units without isolating the ETCS trainborne equipment on traction unit(s) with an in-operative cab. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw):01.@pl,multiple(icl>adj,ant>single))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw):01.@pl,traction(icl>pull>thing):01)\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw),unit(icl>measure>abstract_thing,aoj>uw):01.@pl)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw):01.@pl,without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing),isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing))\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "obj(isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing),equipment(icl>instrumentality>thing).@def)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw):02,traction(icl>pull>thing):02)\n",
+    "plc(equipment(icl>instrumentality>thing).@def,unit(icl>measure>abstract_thing,aoj>uw):02)\n",
+    "cnt(unit(icl>measure>abstract_thing,aoj>uw):02,s.@parenthesis)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw):02,with(icl>how,com>possession,obj>thing,mod<thing))\n",
+    "val(operative(icl>adj,ant>inoperative),\"in.\")\n",
+    "mod(cab(icl>compartment>thing).@indef,operative(icl>adj,ant>inoperative))\n",
+    "obj(with(icl>how,com>possession,obj>thing,mod<thing),cab(icl>compartment>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Information received shall not influence the traction unit(s) with in-operative cabs.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Information received shall not influence the traction unit(s) with in-operative cabs. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(receive(icl>acquire>do,src>thing,obj>thing).@state,information(icl>message>thing))\n",
+    "aoj(influence(icl>affect>be,obj>thing,aoj>thing,gol>thing).@entry.@not.@present.@promise,information(icl>message>thing))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@def,traction(icl>pull>thing))\n",
+    "obj(influence(icl>affect>be,obj>thing,aoj>thing,gol>thing).@entry.@not.@present.@promise,unit(icl>measure>abstract_thing,aoj>uw).@def)\n",
+    "cnt(unit(icl>measure>abstract_thing,aoj>uw).@def,s.@parenthesis)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@def,with(icl>how,com>possession,obj>thing,mod<thing))\n",
+    "val(operative(icl>adj,ant>inoperative),\"in.\")\n",
+    "mod(cab(icl>compartment>thing).@pl,operative(icl>adj,ant>inoperative))\n",
+    "obj(with(icl>how,com>possession,obj>thing,mod<thing),cab(icl>compartment>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train trip function \n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "4.6.12. shall be suppressed in traction unit(s) with in-operative cabs. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(suppress(icl>control>do,agt>thing,obj>thing).@entry.@present.@promise,\"4.6\".@topic)\n",
+    "mod(\"4.6\".@topic,\".12\")\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw),traction(icl>pull>thing))\n",
+    "plc(suppress(icl>control>do,agt>thing,obj>thing).@entry.@present.@promise,unit(icl>measure>abstract_thing,aoj>uw))\n",
+    "cnt(unit(icl>measure>abstract_thing,aoj>uw),s.@parenthesis)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw),with(icl>how,com>possession,obj>thing,mod<thing))\n",
+    "val(operative(icl>adj,ant>inoperative),\"in.\")\n",
+    "mod(cab(icl>compartment>thing).@pl,operative(icl>adj,ant>inoperative))\n",
+    "obj(with(icl>how,com>possession,obj>thing,mod<thing),cab(icl>compartment>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train trip function. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trip(icl>journey>thing),train(icl>public_transport>thing))\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@def,trip(icl>journey>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to use tandem traction units without isolating the ETCS trainborne equipment on the tandem traction unit.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to use tandem traction units without isolating the ETCS trainborne equipment on the tandem traction unit. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw))\n",
+    "mod(traction(icl>pull>thing):01,tandem(icl>bicycle>thing,equ>bicycle-built-for-two):01)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw):01.@pl,traction(icl>pull>thing):01)\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw),unit(icl>measure>abstract_thing,aoj>uw):01.@pl)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw):01.@pl,without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing),isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing))\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "obj(isolate(icl>discriminate>do,cob>thing,agt>thing,obj>concrete_thing),equipment(icl>instrumentality>thing).@def)\n",
+    "mod(traction(icl>pull>thing):02,tandem(icl>bicycle>thing,equ>bicycle-built-for-two):02)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw):02.@def,traction(icl>pull>thing):02)\n",
+    "plc(equipment(icl>instrumentality>thing).@def,unit(icl>measure>abstract_thing,aoj>uw):02.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train trip function \n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "4.6.12. shall be suppressed on the tandem traction unit. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(suppress(icl>control>do,agt>thing,obj>thing).@entry.@present.@promise,\"4.6\".@topic)\n",
+    "mod(\"4.6\".@topic,\".12\")\n",
+    "mod(traction(icl>pull>thing),tandem(icl>bicycle>thing,equ>bicycle-built-for-two))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@def,traction(icl>pull>thing))\n",
+    "plc(suppress(icl>control>do,agt>thing,obj>thing).@entry.@present.@promise,unit(icl>measure>abstract_thing,aoj>uw).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train trip function. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trip(icl>journey>thing),train(icl>public_transport>thing))\n",
+    "mod(function(icl>mathematical_relation>thing).@entry.@def,trip(icl>journey>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall enter the driver ID\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall enter the driver ID. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,driver(icl>operator>thing,ant>nondriver):01.@def)\n",
+    "agt(enter(icl>do,equ>join,agt>volitional_thing,obj>thing),driver(icl>operator>thing,ant>nondriver):01.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,enter(icl>do,equ>join,agt>volitional_thing,obj>thing))\n",
+    "obj(enter(icl>do,equ>join,agt>volitional_thing,obj>thing),driver(icl>operator>thing,ant>nondriver):02.@def)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,that(icl>determiner>adj,com>remote,mod<concrete_thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to drive the train backwards in a supervised way (speed and distance) according to information received from trackside\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to drive the train backwards in a supervised way (speed and distance) according to information received from trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,drive(icl>travel>do,plt>thing,plf>thing,agt>person,ins>vehicle))\n",
+    "obj(drive(icl>travel>do,plt>thing,plf>thing,agt>person,ins>vehicle),train(icl>public_transport>thing).@def)\n",
+    "plt(drive(icl>travel>do,plt>thing,plf>thing,agt>person,ins>vehicle),backwards(icl>how,equ>back))\n",
+    "plc(drive(icl>travel>do,plt>thing,plf>thing,agt>person,ins>vehicle),way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef)\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing).@state,way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef)\n",
+    "and:01(distance(icl>spacing>thing),speed(icl>rate>thing))\n",
+    "src(way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef,according_to(icl>how,src>uw,obj>uw))\n",
+    "obj(according_to(icl>how,src>uw,obj>uw),information(icl>message>thing))\n",
+    "obj(receive(icl>acquire>do,src>thing,obj>thing).@state,information(icl>message>thing))\n",
+    "src(receive(icl>acquire>do,src>thing,obj>thing).@state,trackside)\n",
+    "cnt(way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef,:01.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train speed shall be at or below a speed specified by a national value.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train speed shall be at or below a speed specified by a national value. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(speed(icl>rate>thing):01.@def,train(icl>public_transport>thing))\n",
+    "aoj(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present.@promise,speed(icl>rate>thing):01.@def)\n",
+    "or(below(icl>how,equ>lower,obj>thing,plc<uw),be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present.@promise)\n",
+    "tim(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present.@promise,speed(icl>rate>thing):02.@indef)\n",
+    "obj(specify(icl>do,equ>stipulate,agt>thing,obj>thing).@state,speed(icl>rate>thing):02.@indef)\n",
+    "tim(below(icl>how,equ>lower,obj>thing,plc<uw),speed(icl>rate>thing):02.@indef)\n",
+    "mod(value(icl>property,obj>thing).@indef,national(icl>adj,ant>international))\n",
+    "agt(specify(icl>do,equ>stipulate,agt>thing,obj>thing).@state,value(icl>property,obj>thing).@indef)\n",
+    "obj(below(icl>how,equ>lower,obj>thing,plc<uw),)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall select an override control according to the permission received.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall select an override control according to the permission received. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(control(icl>power>thing).@indef,override(icl>rule>do,equ>overrule,agt>thing,obj>thing))\n",
+    "obj(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@entry.@present.@promise,control(icl>power>thing).@indef)\n",
+    "src(control(icl>power>thing).@indef,according_to(icl>how,src>uw,obj>uw))\n",
+    "obj(according_to(icl>how,src>uw,obj>uw),permission(icl>approval>thing).@def)\n",
+    "obj(receive(icl>acquire>do,src>thing,obj>thing).@state,permission(icl>approval>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The override control shall be protected against inadvertent operation.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The override control shall be protected against inadvertent operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(control(icl>power>thing).@def.@topic,override(icl>rule>do,equ>overrule,agt>thing,obj>thing))\n",
+    "obj(protect(icl>do,equ>defend,rsn>thing,agt>thing,obj>thing,met>thing).@entry.@present.@promise,control(icl>power>thing).@def.@topic)\n",
+    "mod(operation(icl>business_activity>thing),inadvertent(icl>adj,equ>accidental))\n",
+    "rsn(protect(icl>do,equ>defend,rsn>thing,agt>thing,obj>thing,met>thing).@entry.@present.@promise,operation(icl>business_activity>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When the train passes the stop signal, the train trip function shall be suppressed.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When the train passes the stop signal, the train trip function shall be suppressed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(suppress(icl>control>do,agt>thing,obj>thing).@present.@promise,when(icl>how,com>always,tim<uw,obj>uw).@entry)\n",
+    "agt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present,train(icl>public_transport>thing):01.@def)\n",
+    "obj(when(icl>how,com>always,tim<uw,obj>uw).@entry,pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present)\n",
+    "plt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present,stop(icl>stay>thing).@def)\n",
+    "plc(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present,signal(icl>communication>thing))\n",
+    "mod(trip(icl>journey>thing),train(icl>public_transport>thing):02)\n",
+    "mod(function(icl>mathematical_relation>thing).@def.@topic,trip(icl>journey>thing))\n",
+    "obj(suppress(icl>control>do,agt>thing,obj>thing).@present.@promise,function(icl>mathematical_relation>thing).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Actual speed shall still be shown on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Actual speed shall still be shown on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(speed(icl>rate>thing).@topic,actual(icl>adj,ant>potential))\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,speed(icl>rate>thing).@topic)\n",
+    "man(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,still(icl>how,com>duration))\n",
+    "plc(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A special indication shall be shown on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A special indication shall be shown on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(indication(icl>communication>thing).@indef.@topic,special(icl>adj,equ>particular))\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,indication(icl>communication>thing).@indef.@topic)\n",
+    "plc(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The supervised speed shall not be shown on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The supervised speed shall not be shown on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing).@state,speed(icl>rate>thing).@def.@topic)\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@not.@present.@promise,speed(icl>rate>thing).@def.@topic)\n",
+    "plc(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@not.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train shall be capable of receiving any track-to-train information intended and relevant for this train including movement authority.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train shall be capable of receiving any track-to-train information intended and relevant for this train including movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(capable(icl>adj).@entry.@present.@promise,train(icl>public_transport>thing):01.@def)\n",
+    "mod:01(track(icl>line>thing,equ>path),any(icl>adj))\n",
+    "obj:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,track(icl>line>thing,equ>path))\n",
+    "pur(train(icl>public_transport>thing):01.@def,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "obj(train(icl>practice>do,agt>person,obj>person,gol>uw),information(icl>message>thing))\n",
+    "obj(intend(icl>do,equ>predestinate,agt>volitional_thing,obj>thing,rec>volitional_thing).@state,information(icl>message>thing))\n",
+    "and(relevant(icl>adj,ant>irrelevant),intend(icl>do,equ>predestinate,agt>volitional_thing,obj>thing,rec>volitional_thing).@state)\n",
+    "mod(train(icl>public_transport>thing):02,this(icl>determiner>adj,mod<concrete_thing))\n",
+    "obj(relevant(icl>adj,ant>irrelevant),train(icl>public_transport>thing):02)\n",
+    "aoj(include(icl>contain>be,obj>thing,aoj>thing).@progress,train(icl>public_transport>thing):02)\n",
+    "mod(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "obj(include(icl>contain>be,obj>thing,aoj>thing).@progress,authority(icl>abstract_thing,obj>uw))\n",
+    "obj(capable(icl>adj).@entry.@present.@promise,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If supervised by an RBC it shall be possible to command an emergency stop to all trains in a particular area or to a specific train\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If supervised by an RBC it shall be possible to command an emergency stop to all trains in a particular area or to a specific train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "con(possible(icl>adj,ant>impossible).@present.@promise,supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry)\n",
+    "agt(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry,rbc(icl>blood_cell>thing,equ>red_blood_cell).@indef)\n",
+    "mod:01(stop(icl>stay>thing).@indef,emergency(icl>crisis>thing))\n",
+    "obj:01(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry,stop(icl>stay>thing).@indef)\n",
+    "qua:01(train(icl>public_transport>thing):01.@pl,all(icl>quantity,ant>some,per>thing))\n",
+    "rec:01(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry,train(icl>public_transport>thing):01.@pl)\n",
+    "mod:01(area(icl>extent>abstract_thing,obj>thing).@indef,particular(icl>adj,equ>particular))\n",
+    "plc:01(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry,area(icl>extent>abstract_thing,obj>thing).@indef)\n",
+    "mod:01(train(icl>public_transport>thing):02.@indef,specific(icl>adj,equ>particular,ant>general))\n",
+    "plt:01(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry,train(icl>public_transport>thing):02.@indef)\n",
+    "aoj(possible(icl>adj,ant>impossible).@present.@promise,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to command an immediate train stop.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to command an immediate train stop. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing))\n",
+    "mod(stop(icl>stay>thing).@indef,immediate(icl>adj,equ>contiguous))\n",
+    "mod(stop(icl>stay>thing).@indef,train(icl>public_transport>thing))\n",
+    "obj(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing),stop(icl>stay>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to command a conditional emergency stop. If the train has already passed the location for the emergency stop the command shall be ignored\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to command a conditional emergency stop. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing))\n",
+    "mod(stop(icl>stay>thing).@indef,conditional(icl>adj))\n",
+    "mod(stop(icl>stay>thing).@indef,emergency(icl>crisis>thing))\n",
+    "obj(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing),stop(icl>stay>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the train has already passed the location for the emergency stop the command shall be ignored. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@complete,train(icl>public_transport>thing).@def)\n",
+    "con:01(ignore(icl>reject>do,equ>dismiss,com>judicial,agt>thing,obj>information).@present.@promise,pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@complete)\n",
+    "man:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@complete,already(icl>how,ant>not_yet))\n",
+    "plt:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@complete,location(icl>object>thing).@def)\n",
+    "pur:01(location(icl>object>thing).@def,emergency(icl>crisis>thing).@def)\n",
+    "plc:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@complete,stop(icl>stay>thing))\n",
+    "obj:01(ignore(icl>reject>do,equ>dismiss,com>judicial,agt>thing,obj>information).@present.@promise,command(icl>speech_act>thing).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When a train has received an emergency stop ETCS shall command the emergency brake.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When a train has received an emergency stop ETCS shall command the emergency brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@present.@promise,when(icl>how,com>always,tim<uw,obj>uw).@entry)\n",
+    "agt(receive(icl>acquire>do,src>thing,obj>thing).@present.@complete,train(icl>public_transport>thing).@indef)\n",
+    "obj(when(icl>how,com>always,tim<uw,obj>uw).@entry,receive(icl>acquire>do,src>thing,obj>thing).@present.@complete)\n",
+    "mod(stop(icl>stay>thing).@indef,emergency(icl>crisis>thing):01)\n",
+    "agt(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@present.@promise,stop(icl>stay>thing).@indef)\n",
+    "nam(stop(icl>stay>thing).@indef,etcs)\n",
+    "mod(brake(icl>restraint>thing).@def,emergency(icl>crisis>thing):02)\n",
+    "obj(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@present.@promise,brake(icl>restraint>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The emergency stop shall be indicated to the driver on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The emergency stop shall be indicated to the driver on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(stop(icl>stay>thing).@def.@topic,emergency(icl>crisis>thing))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,stop(icl>stay>thing).@def.@topic)\n",
+    "agt(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "plc(driver(icl>operator>thing,ant>nondriver).@def,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to prevent a train from entering a route for which it does not meet the required criteria.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to prevent a train from entering a route for which it does not meet the required criteria. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,prevent(icl>prohibit>do,agt>thing,obj>thing,asp>uw))\n",
+    "obj(prevent(icl>prohibit>do,agt>thing,obj>thing,asp>uw),train(icl>public_transport>thing).@indef)\n",
+    "asp(prevent(icl>prohibit>do,agt>thing,obj>thing,asp>uw),enter(icl>do,equ>join,agt>volitional_thing,obj>thing))\n",
+    "obj(enter(icl>do,equ>join,agt>volitional_thing,obj>thing),route(icl>line>thing,equ>path).@indef)\n",
+    "obj(meet(icl>join>be,cao>thing,aoj>thing).@not.@present,route(icl>line>thing,equ>path).@indef)\n",
+    "aoj(meet(icl>join>be,cao>thing,aoj>thing).@not.@present,it(icl>thing))\n",
+    "mod(criterion(icl>reference_point>thing,equ>standard).@def.@pl,required(icl>adj,agt>thing,obj>thing,gol>thing).@state)\n",
+    "cao(meet(icl>join>be,cao>thing,aoj>thing).@not.@present,criterion(icl>reference_point>thing,equ>standard).@def.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Route unsuitability shall be indicated on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Route unsuitability shall be indicated on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unsuitability(icl>quality>thing,ant>suitability).@topic,route(icl>line>thing,equ>path))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,unsuitability(icl>quality>thing,ant>suitability).@topic)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall be able to override the function when the train is stationary.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall be able to override the function when the train is stationary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(override(icl>rule>do,equ>overrule,agt>thing,obj>thing).@entry.@present.@ability.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(override(icl>rule>do,equ>overrule,agt>thing,obj>thing).@entry.@present.@ability.@promise,function(icl>mathematical_relation>thing).@def)\n",
+    "tim(override(icl>rule>do,equ>overrule,agt>thing,obj>thing).@entry.@present.@ability.@promise,train(icl>public_transport>thing).@def)\n",
+    "aoj(stationary(icl>adj).@present,train(icl>public_transport>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "After overriding this function the movement authority shall be re-established.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "After overriding this function the movement authority shall be re-established. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(reestablish(icl>change>do,equ>restore,agt>thing,obj>thing).@present.@promise,after(icl>how,tim<uw,obj>uw).@entry)\n",
+    "obj(after(icl>how,tim<uw,obj>uw).@entry,override(icl>rule>do,equ>overrule,agt>thing,obj>thing))\n",
+    "mod(function(icl>mathematical_relation>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "obj(override(icl>rule>do,equ>overrule,agt>thing,obj>thing),function(icl>mathematical_relation>thing))\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@def.@topic,movement(icl>happening>thing))\n",
+    "obj(reestablish(icl>change>do,equ>restore,agt>thing,obj>thing).@present.@promise,authority(icl>abstract_thing,obj>uw).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When a traction unit passes a stop-signal the emergency brake shall be triggered.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When a traction unit passes a stop-signal the emergency brake shall be triggered. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(trigger(icl>cause>do,agt>thing,obj>thing).@present.@promise,when(icl>how,com>always,tim<uw,obj>uw).@entry)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@indef,traction(icl>pull>thing))\n",
+    "agt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present,unit(icl>measure>abstract_thing,aoj>uw).@indef)\n",
+    "obj(when(icl>how,com>always,tim<uw,obj>uw).@entry,pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present)\n",
+    "mod(signal(icl>communication>thing).@indef,stop(icl>stay>thing))\n",
+    "plt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present,signal(icl>communication>thing).@indef)\n",
+    "plc(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present,emergency(icl>crisis>thing).@def)\n",
+    "obj(trigger(icl>cause>do,agt>thing,obj>thing).@present.@promise,brake(icl>restraint>thing).@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Operation of the train trip shall be indicated on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Operation of the train trip shall be indicated on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,operation(icl>business_activity>thing).@topic)\n",
+    "mod(trip(icl>journey>thing).@def,train(icl>public_transport>thing))\n",
+    "obj(operation(icl>business_activity>thing).@topic,trip(icl>journey>thing).@def)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The emergency brake shall be applied until the traction unit is stationary.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The emergency brake shall be applied until the traction unit is stationary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(brake(icl>restraint>thing).@def.@topic,emergency(icl>crisis>thing))\n",
+    "obj(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry.@present.@promise,brake(icl>restraint>thing).@def.@topic)\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@def,traction(icl>pull>thing))\n",
+    "tmt(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry.@present.@promise,unit(icl>measure>abstract_thing,aoj>uw).@def)\n",
+    "aoj(stationary(icl>adj).@present,unit(icl>measure>abstract_thing,aoj>uw).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When the traction unit is stationary the driver shall be required to acknowledge the train trip condition. This acknowledgement will release the emergency brake.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When the traction unit is stationary the driver shall be required to acknowledge the train trip condition. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@def,traction(icl>pull>thing))\n",
+    "aoj(be(icl>be).@present,unit(icl>measure>abstract_thing,aoj>uw).@def)\n",
+    "tim(stationary(icl>adj).@entry,be(icl>be).@present)\n",
+    "agt(acknowledge(icl>admit>do,agt>volitional_thing,obj>thing),driver(icl>operator>thing,ant>nondriver).@def.@topic)\n",
+    "obj(stationary(icl>adj).@entry,require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@present.@promise)\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@present.@promise,acknowledge(icl>admit>do,agt>volitional_thing,obj>thing))\n",
+    "mod(trip(icl>journey>thing),train(icl>public_transport>thing))\n",
+    "mod(condition(icl>state>abstract_thing,aoj>thing).@def,trip(icl>journey>thing))\n",
+    "obj(acknowledge(icl>admit>do,agt>volitional_thing,obj>thing),condition(icl>state>abstract_thing,aoj>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This acknowledgement will release the emergency brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(acknowledgement(icl>message>thing,equ>acknowledgment),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "agt(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry.@future,acknowledgement(icl>message>thing,equ>acknowledgment))\n",
+    "mod(brake(icl>restraint>thing).@def,emergency(icl>crisis>thing))\n",
+    "obj(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry.@future,brake(icl>restraint>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "After the acknowledgement the driver shall be able to continue the movement\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "After the acknowledgement the driver shall be able to continue the movement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(continue(icl>be,equ>extend,obj>thing,aoj>thing).@present.@ability.@promise,after(icl>how,tim<uw,obj>uw).@entry)\n",
+    "obj(after(icl>how,tim<uw,obj>uw).@entry,acknowledgement(icl>message>thing,equ>acknowledgment).@def)\n",
+    "aoj(continue(icl>be,equ>extend,obj>thing,aoj>thing).@present.@ability.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(continue(icl>be,equ>extend,obj>thing,aoj>thing).@present.@ability.@promise,movement(icl>happening>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "After the acknowledgement the train shall be able to be driven backwards for a certain distance defined by national value\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "After the acknowledgement the train shall be able to be driven backwards for a certain distance defined by national value. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@present.@ability.@promise,after(icl>how,tim<uw,obj>uw).@entry)\n",
+    "obj(after(icl>how,tim<uw,obj>uw).@entry,acknowledgement(icl>message>thing,equ>acknowledgment).@def)\n",
+    "aoj(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@present.@ability.@promise,train(icl>public_transport>thing).@def)\n",
+    "plt(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@present.@ability.@promise,backwards(icl>how,equ>back))\n",
+    "mod(distance(icl>spacing>thing).@indef,certain(icl>adj,equ>certain))\n",
+    "pur(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@present.@ability.@promise,distance(icl>spacing>thing).@indef)\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@state,distance(icl>spacing>thing).@indef)\n",
+    "mod(value(icl>property,obj>thing),national(icl>adj,ant>international))\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing).@state,value(icl>property,obj>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS trainborne equipment shall transmit its own train identification to the RBC.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall transmit its own train identification to the RBC. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "agt(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "pos(own(icl>adj,equ>own),it(icl>living_thing))\n",
+    "mod(identification(icl>determination>thing,equ>designation),own(icl>adj,equ>own))\n",
+    "mod(identification(icl>determination>thing,equ>designation),train(icl>public_transport>thing))\n",
+    "obj(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@entry.@present.@promise,identification(icl>determination>thing,equ>designation))\n",
+    "ben(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@entry.@present.@promise,rbc(icl>blood_cell>thing,equ>red_blood_cell).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train running number shall consist of a maximum of 8 numeric digits.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train running number shall consist of a maximum of 8 numeric digits. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(number(icl>abstract_thing,icl>quantity,obj>thing).@def,train(icl>public_transport>thing))\n",
+    "mod(number(icl>abstract_thing,icl>quantity,obj>thing).@def,running(icl>adj,equ>running))\n",
+    "aoj(consist(icl>be,equ>lie,obj>uw,aoj>thing).@entry.@present.@promise,number(icl>abstract_thing,icl>quantity,obj>thing).@def)\n",
+    "obj(consist(icl>be,equ>lie,obj>uw,aoj>thing).@entry.@present.@promise,maximum(icl>extremum>thing,ant>minimum).@indef)\n",
+    "qua(digit(icl>integer>thing).@pl,8)\n",
+    "mod(digit(icl>integer>thing).@pl,numerical(icl>adj,equ>numeric))\n",
+    "mod(maximum(icl>extremum>thing,ant>minimum).@indef,digit(icl>integer>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "On demand, the position of the front end of the train at the time of the demand shall be indicated on the DMI. This shall be possible while the train is moving or stationary.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "On demand, the position of the front end of the train at the time of the demand shall be indicated on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@present.@promise,demand(icl>property,obj>uw,aoj>uw):01.@entry)\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@present.@promise,position(icl>occupation>thing).@def.@topic)\n",
+    "mod(end(icl>moment>time,ant>beginning).@def,front(icl>adj,equ>front,ant>back))\n",
+    "obj(position(icl>occupation>thing).@def.@topic,end(icl>moment>time,ant>beginning).@def)\n",
+    "obj(end(icl>moment>time,ant>beginning).@def,train(icl>public_transport>thing).@def)\n",
+    "tim(train(icl>public_transport>thing).@def,time(icl>abstract_thing,equ>occasion).@def)\n",
+    "obj(time(icl>abstract_thing,equ>occasion).@def,demand(icl>property,obj>uw,aoj>uw):02.@def)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This shall be possible while the train is moving or stationary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,this(icl>thing,equ>it,equ>that))\n",
+    "dur(possible(icl>adj,ant>impossible).@entry.@present.@promise,while(icl>how,equ>whilst,tim<uw,obj>uw))\n",
+    "obj(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing).@present.@progress,train(icl>public_transport>thing).@def)\n",
+    "aoj(stationary(icl>adj),train(icl>public_transport>thing).@def)\n",
+    "obj(while(icl>how,equ>whilst,tim<uw,obj>uw),move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing).@present.@progress)\n",
+    "obj(or(icl>how,obj>uw,or<uw),move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing).@present.@progress)\n",
+    "man(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing).@present.@progress,stationary(icl>adj))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS on-board shall be capable of receiving information about pantograph and power supply from the trackside.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS on-board shall be capable of receiving information about pantograph and power supply from the trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "aoj(capable(icl>adj),etcs.@def)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on-board)\n",
+    "and(:02,capable(icl>adj))\n",
+    "obj:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,information(icl>message>thing))\n",
+    "obj:01(information(icl>message>thing),pantograph(icl>mechanical_device>thing))\n",
+    "obj:02(power(icl>supply>do,agt>thing,obj>thing).@entry,supply(icl>indefinite_quantity>thing))\n",
+    "obj:02(supply(icl>indefinite_quantity>thing),trackside.@def)\n",
+    "obj(capable(icl>adj),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS trainborne equipment shall indicate on the DMI the information regarding pantograph and power supply.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall indicate on the DMI the information regarding pantograph and power supply. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "aoj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "plc(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,dmi.@def)\n",
+    "and:02(power(icl>quality>thing,ant>powerlessness).@entry,information(icl>message>thing).@entry.@def)\n",
+    "obj:01(regarding(icl>how,equ>concerning,obj>thing).@entry,pantograph(icl>mechanical_device>thing))\n",
+    "obj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@present.@promise,supply(icl>provide>do,agt>thing,obj>thing,rec>thing).@present)\n",
+    "mod(:02.@_hn-scope,:01)\n",
+    "agt(supply(icl>provide>do,agt>thing,obj>thing,rec>thing).@present,:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The information regarding lowering and raising of the pantograph and opening/closing of the circuit breaker shall be provided separately and in combinations.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The information regarding lowering and raising of the pantograph and opening/closing of the circuit breaker shall be provided separately and in combinations. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,information(icl>message>thing).@def.@topic)\n",
+    "mod(information(icl>message>thing).@def.@topic,regarding(icl>how,equ>concerning,obj>thing))\n",
+    "and(:01,lower(icl>take_down>do,plt>thing,plf>thing,agt>thing,obj>concrete_thing))\n",
+    "obj:01(raise(icl>increase>do,src>thing,obj>thing,gol>thing).@entry,pantograph(icl>mechanical_device>thing).@def)\n",
+    "or(closing(icl>motion>thing,equ>shutting,ant>opening),opening(icl>space>thing))\n",
+    "obj(regarding(icl>how,equ>concerning,obj>thing),closing(icl>motion>thing,equ>shutting,ant>opening))\n",
+    "mod(breaker(icl>wave>thing,equ>surf).@def,circuit(icl>electrical_device>thing))\n",
+    "obj(closing(icl>motion>thing,equ>shutting,ant>opening),breaker(icl>wave>thing,equ>surf).@def)\n",
+    "and(be(icl>be,equ>be_located,aoj>thing,plc>uw),provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise)\n",
+    "man(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,separately(icl>how,equ>individually,com>separate))\n",
+    "man(be(icl>be,equ>be_located,aoj>thing,plc>uw),separately(icl>how,equ>individually,com>separate))\n",
+    "scn(be(icl>be,equ>be_located,aoj>thing,plc>uw),combination(icl>collection>thing).@pl)\n",
+    "and(opening(icl>space>thing),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS on-board shall be capable of receiving information regarding air tightness from the trackside.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS on-board shall be capable of receiving information regarding air tightness from the trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs.@def)\n",
+    "aoj(capable(icl>adj),etcs.@def)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on-board)\n",
+    "obj:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,information(icl>message>thing))\n",
+    "man:01(receive(icl>acquire>do,src>thing,obj>thing).@entry,regarding(icl>how,equ>concerning,obj>thing))\n",
+    "mod:01(tightness(icl>immovability>thing,ant>looseness),air(icl>travel>abstract_thing,equ>air_travel))\n",
+    "obj:01(regarding(icl>how,equ>concerning,obj>thing),tightness(icl>immovability>thing,ant>looseness))\n",
+    "frm:01(tightness(icl>immovability>thing,ant>looseness),trackside.@def)\n",
+    "obj(capable(icl>adj),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to send plain text messages from track to train.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to send plain text messages from track to train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "pur(train(icl>practice>do,agt>person,obj>person,gol>uw),perform_an_action(icl>do,agt>thing,obj>process))\n",
+    "mod(message(icl>communication>thing).@pl,plain(icl>adj,equ>apparent))\n",
+    "mod(message(icl>communication>thing).@pl,text(icl>passage>thing))\n",
+    "obj(perform_an_action(icl>do,agt>thing,obj>process),message(icl>communication>thing).@pl)\n",
+    "man(perform_an_action(icl>do,agt>thing,obj>process),track(icl>line>thing,equ>path))\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When the plain text message appears on the DMI, the driver shall be alerted.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When the plain text message appears on the DMI, the driver shall be alerted. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(alert(icl>do,equ>warn,rsn>thing,agt>volitional_thing,obj>person).@present.@promise,when(icl>how,com>always,tim<uw,obj>uw).@entry)\n",
+    "mod(text(icl>passage>thing),plain(icl>adj,equ>apparent))\n",
+    "mod(message(icl>communication>thing).@def,text(icl>passage>thing))\n",
+    "obj(appear(icl>occur,obj>thing).@present,message(icl>communication>thing).@def)\n",
+    "obj(when(icl>how,com>always,tim<uw,obj>uw).@entry,appear(icl>occur,obj>thing).@present)\n",
+    "plc(appear(icl>occur,obj>thing).@present,dmi.@def)\n",
+    "obj(alert(icl>do,equ>warn,rsn>thing,agt>volitional_thing,obj>person).@present.@promise,driver(icl>operator>thing,ant>nondriver).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The onboard equipment shall display plain text messages as received.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The onboard equipment shall display plain text messages as received. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(equipment(icl>instrumentality>thing).@def,onboard)\n",
+    "agt(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "mod(message(icl>communication>thing).@pl,plain(icl>adj,equ>apparent))\n",
+    "mod(message(icl>communication>thing).@pl,text(icl>passage>thing))\n",
+    "obj(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,message(icl>communication>thing).@pl)\n",
+    "man(message(icl>communication>thing).@pl,as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw),receive(icl>acquire>do,src>thing,obj>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The character set used shall support different languages.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The character set used shall support different languages. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(set(icl>collection>thing).@def,character(icl>property>thing,equ>quality))\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,set(icl>collection>thing).@def)\n",
+    "agt(support(icl>help>do,agt>thing,obj>person,met>thing,scn>uw).@entry.@present.@promise,set(icl>collection>thing).@def)\n",
+    "mod(language(icl>communication>thing).@pl,different(icl>adj,ant>same))\n",
+    "obj(support(icl>help>do,agt>thing,obj>person,met>thing,scn>uw).@entry.@present.@promise,language(icl>communication>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to send fixed text messages from track to train\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to send fixed text messages from track to train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "pur:01(train(icl>practice>do,agt>person,obj>person,gol>uw),perform_an_action(icl>do,agt>thing,obj>process))\n",
+    "mod:01(message(icl>communication>thing).@entry.@pl,text(icl>passage>thing))\n",
+    "obj:01(perform_an_action(icl>do,agt>thing,obj>process),message(icl>communication>thing).@entry.@pl)\n",
+    "obj:01(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,message(icl>communication>thing).@entry.@pl)\n",
+    "man:01(perform_an_action(icl>do,agt>thing,obj>process),track(icl>line>thing,equ>path))\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Fixed text messages shall be provided in the language selected by the driver\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Fixed text messages shall be provided in the language selected by the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(message(icl>communication>thing).@pl.@topic,text(icl>passage>thing))\n",
+    "obj(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,message(icl>communication>thing).@pl.@topic)\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,message(icl>communication>thing).@pl.@topic)\n",
+    "plc(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@promise,language(icl>communication>thing).@def)\n",
+    "obj(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@state,language(icl>communication>thing).@def)\n",
+    "agt(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw).@state,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to send information regarding the inhibition of the following different types of brake:\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Regenerative brake, Eddy current brake, Magnetic shoe brake.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(brake(icl>restraint>thing):01.@entry,regenerative)\n",
+    "and(:01.@_hn-scope,brake(icl>restraint>thing):01.@entry)\n",
+    "mod:01(brake(icl>restraint>thing):02.@entry,eddy(iof>religious_person>thing))\n",
+    "mod:01(brake(icl>restraint>thing):02.@entry,current(icl>adj,ant>noncurrent))\n",
+    "and:01(brake(icl>restraint>thing):03.@entry,brake(icl>restraint>thing):02.@entry)\n",
+    "mod(shoe(icl>footwear>thing),magnetic(icl>adj,com>magnetism).@maiuscul)\n",
+    "mod(brake(icl>restraint>thing):02.@entry,shoe(icl>footwear>thing))\n",
+    "mod(brake(icl>restraint>thing):01.@entry,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to send information regarding the inhibition of the following different types of brake:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing))\n",
+    "obj(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing),information(icl>message>thing))\n",
+    "rec(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing),regarding(icl>how,equ>concerning,obj>thing))\n",
+    "obj(regarding(icl>how,equ>concerning,obj>thing),inhibition(icl>abstinence>thing).@def)\n",
+    "mod(type(icl>abstract_thing).@def.@pl,following(icl>adj,ant>leading))\n",
+    "mod(type(icl>abstract_thing).@def.@pl,different(icl>adj,ant>same))\n",
+    "obj(inhibition(icl>abstinence>thing).@def,type(icl>abstract_thing).@def.@pl)\n",
+    "obj(type(icl>abstract_thing).@def.@pl,brake(icl>restraint>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Information shall be shown on the DMI\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Information shall be shown on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,information(icl>message>thing).@topic)\n",
+    "plc(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS on-board shall be capable of sending to the trackside train integrity information detected by a system outside ETCS\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS on-board shall be capable of sending to the trackside train integrity information detected by a system outside ETCS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs:01.@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs:01.@def)\n",
+    "aoj(capable(icl>adj),etcs:01.@def)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on-board)\n",
+    "obj(capable(icl>adj),send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing))\n",
+    "mod(train(icl>public_transport>thing),trackside)\n",
+    "mod(integrity(icl>state>thing).@def,train(icl>public_transport>thing))\n",
+    "mod(information(icl>message>thing),integrity(icl>state>thing).@def)\n",
+    "rec(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing),information(icl>message>thing))\n",
+    "obj(detect(icl>sight>do,equ>discover,agt>thing,obj>uw,plc>thing).@state,information(icl>message>thing))\n",
+    "met(detect(icl>sight>do,equ>discover,agt>thing,obj>uw,plc>thing).@state,system(icl>group>thing).@indef)\n",
+    "plc(system(icl>group>thing).@indef,outside(icl>how,ant>inside,obj>thing,plc<uw))\n",
+    "obj(outside(icl>how,ant>inside,obj>thing,plc<uw),etcs:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall be able to confirm the train integrity to the RBC manually. The confirmation requires the train to be stationary.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall be able to confirm the train integrity to the RBC manually. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing).@entry.@present.@ability.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(integrity(icl>state>thing).@def,train(icl>public_transport>thing))\n",
+    "obj(confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing).@entry.@present.@ability.@promise,integrity(icl>state>thing).@def)\n",
+    "to(integrity(icl>state>thing).@def,rbc(icl>blood_cell>thing,equ>red_blood_cell).@def)\n",
+    "man(confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing).@entry.@present.@ability.@promise,manually(icl>how,com>manual))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The confirmation requires the train to be stationary. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(require(icl>request>do,agt>person,obj>uw,rec>thing).@entry.@present,confirmation(icl>proof>thing).@def)\n",
+    "obj(require(icl>request>do,agt>person,obj>uw,rec>thing).@entry.@present,train(icl>public_transport>thing).@def)\n",
+    "obj:01(be(icl>be).@entry,stationary(icl>adj))\n",
+    "rec(require(icl>request>do,agt>person,obj>uw,rec>thing).@entry.@present,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The on board shall be capable of sending train data to the trackside after confirmation by the driver, or when entering the RBC area\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The on board shall be capable of sending train data to the trackside after confirmation by the driver, or when entering the RBC area. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(promise(icl>modal>be,obj>uw,aoj>thing).@entry,on board)\n",
+    "obj:01(be(icl>be).@entry,capable(icl>adj).@def)\n",
+    "mod:02(data(icl>collection>thing),train(icl>public_transport>thing))\n",
+    "obj:02(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing).@entry,data(icl>collection>thing))\n",
+    "rec:02(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing).@entry,trackside.@def)\n",
+    "tim:02(trackside.@def,after(icl>how,tim<uw,obj>uw))\n",
+    "obj:02(after(icl>how,tim<uw,obj>uw),confirmation(icl>proof>thing))\n",
+    "agt:02(confirmation(icl>proof>thing),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "tim:01(area(icl>extent>abstract_thing,obj>thing).@def,enter(icl>move>do,plt>thing,plf>thing,agt>thing))\n",
+    "mod:01(area(icl>extent>abstract_thing,obj>thing).@def,rbc(icl>blood_cell>thing,equ>red_blood_cell))\n",
+    "obj:01(capable(icl>adj).@def,area(icl>extent>abstract_thing,obj>thing).@def)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "or:01(area(icl>extent>abstract_thing,obj>thing).@def,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "\tThe following train data shall be sent from the on board to the trackside:\n",
+    "\t\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train running number, STM ready for use, train gauge, Max. axle load, status of air tight system, type of el. power accepted, international train category, max. train speed, train length.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(run(icl>direct>do,equ>operate,agt>volitional_thing,obj>thing).@progress,train(icl>public_transport>thing):01)\n",
+    "plc(el.@entry,train(icl>public_transport>thing):01)\n",
+    "and(load(icl>weight>thing),run(icl>direct>do,equ>operate,agt>volitional_thing,obj>thing).@progress)\n",
+    "man(run(icl>direct>do,equ>operate,agt>volitional_thing,obj>thing).@progress,numbly(icl>how,com>numb))\n",
+    "and(gauge(icl>measuring_instrument>thing),stm)\n",
+    "mod(stm,ready(icl>adj,ant>unready))\n",
+    "obj(ready(icl>adj,ant>unready),use(icl>activity>thing))\n",
+    "mod(gauge(icl>measuring_instrument>thing),train(icl>public_transport>thing):02)\n",
+    "obj(run(icl>direct>do,equ>operate,agt>volitional_thing,obj>thing).@progress,gauge(icl>measuring_instrument>thing))\n",
+    "mod(axle(icl>shaft>thing),max(icl>gamma_hydroxybutyrate>thing,equ>soap))\n",
+    "mod(load(icl>weight>thing),axle(icl>shaft>thing))\n",
+    "and(status(icl>state>thing),load(icl>weight>thing))\n",
+    "mod(tight(icl>adj,ant>loose),air(icl>travel>abstract_thing,equ>air_travel))\n",
+    "mod(system(icl>group>thing),tight(icl>adj,ant>loose))\n",
+    "obj(status(icl>state>thing),system(icl>group>thing))\n",
+    "cnt(system(icl>group>thing),type(icl>abstract_thing))\n",
+    "obj(load(icl>weight>thing),of(icl>how,com>quality,obj>thing))\n",
+    "fictit(el.@entry,power(icl>quality>thing,ant>powerlessness))\n",
+    "obj(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@state,power(icl>quality>thing,ant>powerlessness))\n",
+    "obj(train(icl>practice>do,agt>person,obj>person,gol>uw):01,power(icl>quality>thing,ant>powerlessness))\n",
+    "and(international(icl>adj,ant>national),accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@state)\n",
+    "and(train(icl>practice>do,agt>person,obj>person,gol>uw):02.@present,train(icl>practice>do,agt>person,obj>person,gol>uw):01)\n",
+    "agt(train(icl>practice>do,agt>person,obj>person,gol>uw):02.@present,category(icl>collection>thing,equ>class))\n",
+    "agt(speed(icl>travel>do,equ>rush,agt>volitional_thing),category(icl>collection>thing,equ>class))\n",
+    "agt(train(icl>practice>do,agt>person,obj>person,gol>uw):02.@present,max)\n",
+    "mod(length(icl>fundamental_quantity>thing),train(icl>public_transport>thing):03)\n",
+    "fictit(el.@entry,length(icl>fundamental_quantity>thing))\n",
+    "man(numbly(icl>how,com>numb),more(icl>how))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "The following train data shall be sent from the on board to the trackside:. \n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "It shall be possible to revoke a Movement Authority that has already been issued to a train in a co-operative way between RBC and train.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "It shall be possible to revoke a Movement Authority that has already been issued to a train in a co-operative way between RBC and train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,revoke(icl>cancel>do,agt>thing,obj>thing))\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@indef.@maiuscul,movement(icl>happening>thing).@maiuscul)\n",
+    "obj(revoke(icl>cancel>do,agt>thing,obj>thing),authority(icl>abstract_thing,obj>uw).@indef.@maiuscul)\n",
+    "obj(issue(icl>do,equ>distribute,plf>thing,agt>thing,obj>thing,rec>thing).@present.@complete,authority(icl>abstract_thing,obj>uw).@indef.@maiuscul)\n",
+    "man(issue(icl>do,equ>distribute,plf>thing,agt>thing,obj>thing,rec>thing).@present.@complete,already(icl>how,ant>not_yet))\n",
+    "rec(issue(icl>do,equ>distribute,plf>thing,agt>thing,obj>thing,rec>thing).@present.@complete,train(icl>public_transport>thing):01.@indef)\n",
+    "mod(way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef,cooperative(icl>adj,equ>combined))\n",
+    "plc(train(icl>public_transport>thing):01.@indef,way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef)\n",
+    "plc(way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef,between(icl>how,obj>thing,plc<uw))\n",
+    "and(train(icl>public_transport>thing):02,rbc(icl>blood_cell>thing,equ>red_blood_cell))\n",
+    "obj(between(icl>how,obj>thing,plc<uw),train(icl>public_transport>thing):02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The co-operative revocation of the MA shall be possible to a new target location, proposed from RBC.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The co-operative revocation of the MA shall be possible to a new target location, proposed from RBC. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(revocation(icl>abrogation>thing).@def,cooperative(icl>adj,equ>combined))\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,revocation(icl>abrogation>thing).@def)\n",
+    "obj(revocation(icl>abrogation>thing).@def,ma(icl>mother>thing).@def)\n",
+    "mod(location(icl>object>thing).@indef,new(icl>adj,ant>old))\n",
+    "mod(location(icl>object>thing).@indef,target(icl>reference_point>thing))\n",
+    "plt(possible(icl>adj,ant>impossible).@entry.@present.@promise,location(icl>object>thing).@indef)\n",
+    "obj(propose(icl>do,equ>suggest,agt>volitional_thing,obj>uw,pur>thing,rec>thing).@state,location(icl>object>thing).@indef)\n",
+    "man(propose(icl>do,equ>suggest,agt>volitional_thing,obj>uw,pur>thing,rec>thing).@state,from(icl>how,equ>according_to,obj>thing))\n",
+    "obj(from(icl>how,equ>according_to,obj>thing),rbc(icl>blood_cell>thing,equ>red_blood_cell))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The new target location shall be checked for acceptance by the on board.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If a train cannot stop at the proposed new target location it shall reject the request and keep the old target location.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If a train cannot stop at the proposed new target location it shall reject the request and keep the old target location. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt:01(stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@present.@ability-not,train(icl>public_transport>thing).@indef)\n",
+    "con:01(reject(icl>evaluate>do,agt>thing,obj>thing).@present.@promise,stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@present.@ability-not)\n",
+    "mod:01(location(icl>object>thing):01.@def,new(icl>adj,ant>old))\n",
+    "mod:01(location(icl>object>thing):01.@def,target(icl>reference_point>thing):01)\n",
+    "plc:01(stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@present.@ability-not,location(icl>object>thing):01.@def)\n",
+    "obj:01(propose(icl>do,equ>suggest,agt>volitional_thing,obj>uw,pur>thing,rec>thing).@state,location(icl>object>thing):01.@def)\n",
+    "agt:01(reject(icl>evaluate>do,agt>thing,obj>thing).@present.@promise,it(icl>thing))\n",
+    "obj:01(reject(icl>evaluate>do,agt>thing,obj>thing).@present.@promise,request(icl>message>thing).@def)\n",
+    "mod(location(icl>object>thing):02.@def,old(icl>adj,ant>new))\n",
+    "mod(location(icl>object>thing):02.@def,target(icl>reference_point>thing):02)\n",
+    "obj(keep(icl>be,equ>continue,obj>action,aoj>thing),location(icl>object>thing):02.@def)\n",
+    "and(keep(icl>be,equ>continue,obj>action,aoj>thing),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The Reversing function shall only be possible in one active cab which is not closed at any time during the procedure.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The Reversing function shall only be possible in one active cab which is not closed at any time during the procedure. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(reverse(icl>move>do,agt>thing).@progress.@maiuscul,function(icl>mathematical_relation>thing).@def)\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,function(icl>mathematical_relation>thing).@def)\n",
+    "man(possible(icl>adj,ant>impossible).@entry.@present.@promise,only(icl>how,com>result))\n",
+    "qua(cab(icl>compartment>thing),one(icl>digit>thing))\n",
+    "mod(cab(icl>compartment>thing),active(icl>adj))\n",
+    "plc(possible(icl>adj,ant>impossible).@entry.@present.@promise,cab(icl>compartment>thing))\n",
+    "obj(close(icl>shut>do,agt>person,obj>thing,ins>uw).@not.@present,cab(icl>compartment>thing))\n",
+    "mod(time(icl>abstract_thing,equ>occasion),any(icl>adj))\n",
+    "tim(close(icl>shut>do,agt>person,obj>thing,ins>uw).@not.@present,time(icl>abstract_thing,equ>occasion))\n",
+    "dur(time(icl>abstract_thing,equ>occasion),procedure(icl>activity>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Reversing shall be possible as defined by a value given with the MA\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Reversing shall be possible as defined by a value given with the MA. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(possible(icl>adj,ant>impossible).@entry.@present.@promise,reverse(icl>change>do,agt>thing,obj>thing))\n",
+    "man(possible(icl>adj,ant>impossible).@entry.@present.@promise,as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw),define(icl>characterize>be,obj>uw,aoj>thing))\n",
+    "aoj(define(icl>characterize>be,obj>uw,aoj>thing),value(icl>property,obj>thing).@indef)\n",
+    "obj(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@state,value(icl>property,obj>thing).@indef)\n",
+    "ptn(give(icl>supply>occur,equ>yield,cob>abstract_thing,obj>thing,ben>person).@state,ma(icl>mother>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver shall be able to use the Reversing function without needing to re-confirm the train data.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver shall be able to use the Reversing function without needing to re-confirm the train data. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry.@present.@ability.@promise,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry.@present.@ability.@promise,function(icl>mathematical_relation>thing).@def)\n",
+    "agt(reverse(icl>move>do,agt>thing).@progress.@maiuscul,function(icl>mathematical_relation>thing).@def)\n",
+    "mod(function(icl>mathematical_relation>thing).@def,without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "mod:02(confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing).@entry,re(icl>solfa_syllable>thing))\n",
+    "mod:02(data(icl>collection>thing).@def,train(icl>public_transport>thing))\n",
+    "obj:02(confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing).@entry,data(icl>collection>thing).@def)\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing),:01)\n",
+    "obj:01(need(icl>require>be,obj>uw,aoj>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Reversing shall be supervised to a distance and speed set as National Values\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Reversing shall be supervised to a distance and speed set as National Values. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,reverse(icl>change>do,agt>thing,obj>thing).@topic)\n",
+    "man(supervise(icl>control>do,agt>volitional_thing,obj>thing).@entry.@present.@promise,to(icl>how,com>content,obj>thing))\n",
+    "and(speed(icl>rate>thing),distance(icl>spacing>thing).@indef)\n",
+    "obj(set(icl>displace>do,agt>thing,obj>thing,plc>uw).@state,speed(icl>rate>thing))\n",
+    "mod(value(icl>property,obj>thing).@pl.@maiuscul,speed(icl>rate>thing))\n",
+    "man(national(icl>adj,ant>international).@maiuscul,as(icl>how,equ>equally,com>equal))\n",
+    "mod(value(icl>property,obj>thing).@pl.@maiuscul,national(icl>adj,ant>international).@maiuscul)\n",
+    "obj(to(icl>how,com>content,obj>thing),value(icl>property,obj>thing).@pl.@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The distance supervised can be extended from the trackside.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The distance supervised can be extended from the trackside. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing).@state,distance(icl>spacing>thing).@def.@topic)\n",
+    "obj(extend(icl>do,equ>widen,plt>thing,plf>thing,agt>thing,obj>thing,val>thing).@entry.@present.@ability,distance(icl>spacing>thing).@def.@topic)\n",
+    "plf(extend(icl>do,equ>widen,plt>thing,plf>thing,agt>thing,obj>thing,val>thing).@entry.@present.@ability,trackside.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Once the train starts reversing the MA shall be cancelled.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Once the train starts reversing the MA shall be cancelled. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "tim(cancel(icl>change>do,equ>revoke,agt>volitional_thing,obj>event).@present.@promise,once(icl>how,equ>as_soon_as,tim<uw,obj>uw).@entry)\n",
+    "agt(start(icl>begin>do,src>uw,agt>thing,obj>uw).@present,train(icl>public_transport>thing).@def)\n",
+    "obj(once(icl>how,equ>as_soon_as,tim<uw,obj>uw).@entry,start(icl>begin>do,src>uw,agt>thing,obj>uw).@present)\n",
+    "obj(start(icl>begin>do,src>uw,agt>thing,obj>uw).@present,reverse(icl>change>do,agt>thing,obj>thing))\n",
+    "obj(cancel(icl>change>do,equ>revoke,agt>volitional_thing,obj>event).@present.@promise,ma(icl>mother>thing).@def.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The train shall be able to automatically pass from one RBC area to another without driver intervention.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train shall be able to automatically pass from one RBC area to another without driver intervention. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@ability.@promise,train(icl>public_transport>thing).@def)\n",
+    "man(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@ability.@promise,automatically(icl>how,com>automatic))\n",
+    "qua(area(icl>extent>abstract_thing,obj>thing),one(icl>digit>thing))\n",
+    "mod(area(icl>extent>abstract_thing,obj>thing),rbc(icl>blood_cell>thing,equ>red_blood_cell))\n",
+    "plf(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@ability.@promise,area(icl>extent>abstract_thing,obj>thing))\n",
+    "plt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@ability.@promise,another(icl>adj,equ>another))\n",
+    "mod(another(icl>adj,equ>another),without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "mod(intervention(icl>engagement>thing),driver(icl>operator>thing,ant>nondriver))\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing),intervention(icl>engagement>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If the train is equipped with two operational radios there shall be no performance penalty as a result of a transition from one RBC to another (train spacing and train speed).\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the train is equipped with two operational radios there shall be no performance penalty as a result of a transition from one RBC to another (train spacing and train speed). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:02(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@entry.@present,train(icl>public_transport>thing):01.@def.@topic)\n",
+    "con:02(be(icl>be).@present.@promise,equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@entry.@present)\n",
+    "qua:02(radio(icl>media>abstract_thing).@pl,two(icl>digit>thing))\n",
+    "mod:02(radio(icl>media>abstract_thing).@pl,operational(icl>adj,com>operation))\n",
+    "ins:02(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@entry.@present,radio(icl>media>abstract_thing).@pl)\n",
+    "mod:02(performance(icl>show>thing),no(icl>quantity,qua<thing))\n",
+    "mod:02(penalty(icl>social_control>thing,equ>punishment),performance(icl>show>thing))\n",
+    "aoj:02(be(icl>be).@present.@promise,penalty(icl>social_control>thing,equ>punishment))\n",
+    "man:02(penalty(icl>social_control>thing,equ>punishment),as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj:02(as(icl>how,com>degree,obj>uw,man<uw),result(icl>phenomenon>thing,equ>consequence).@indef)\n",
+    "obj:02(result(icl>phenomenon>thing,equ>consequence).@indef,transition(icl>change_of_state>thing,equ>passage).@indef)\n",
+    "obj:02(transition(icl>change_of_state>thing,equ>passage).@indef,one(icl>digit>abstract_thing))\n",
+    "obj:02(one(icl>digit>abstract_thing),rbc(icl>blood_cell>thing,equ>red_blood_cell))\n",
+    "man:02(transition(icl>change_of_state>thing,equ>passage).@indef,another(icl>adj,equ>another))\n",
+    "mod:01(speed(icl>rate>thing),train(icl>public_transport>thing):03)\n",
+    "mod:01(train(icl>public_transport>thing):02.@entry,speed(icl>rate>thing))\n",
+    "obj:02(another(icl>adj,equ>another),train(icl>public_transport>thing):04)\n",
+    "agt:02(space(icl>put>do,cob>concrete_thing,agt>volitional_thing,obj>concrete_thing).@progress.@parenthesis,train(icl>public_transport>thing):04)\n",
+    "and:02(train(icl>public_transport>thing):04,:01.@parenthesis)\n",
+    "mod:02(train(icl>public_transport>thing):04,:01.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If the train is equipped with only one operational radio, passing from one RBC to another shall still be possible but might result in a performance penalty.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If the train is equipped with only one operational radio, passing from one RBC to another shall still be possible but might result in a performance penalty. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:01(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@entry.@present,train(icl>public_transport>thing).@def.@topic)\n",
+    "mod:01(one(icl>digit>thing),only(icl>how,equ>merely))\n",
+    "qua:01(radio(icl>media>abstract_thing),one(icl>digit>thing))\n",
+    "mod:01(radio(icl>media>abstract_thing),operational(icl>adj,com>operation))\n",
+    "ins:01(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@entry.@present,radio(icl>media>abstract_thing))\n",
+    "aoj(possible(icl>adj,ant>impossible),pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing))\n",
+    "obj:01(train(icl>public_transport>thing).@def.@topic,one(icl>digit>abstract_thing))\n",
+    "plc:02(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),rbc(icl>blood_cell>thing,equ>red_blood_cell))\n",
+    "plt:02(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),another(icl>adj,equ>another))\n",
+    "obj(but(icl>how,equ>however,obj>uw,and<uw),promise(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "man(possible(icl>adj,ant>impossible),still(icl>how,com>duration))\n",
+    "and(:03,but(icl>how,equ>however,obj>uw,and<uw))\n",
+    "mod:03(penalty(icl>social_control>thing,equ>punishment).@indef,performance(icl>show>thing))\n",
+    "gol:03(result(icl>produce>be,aoj>thing,gol>uw).@entry.@past.@grant,penalty(icl>social_control>thing,equ>punishment).@indef)\n",
+    "con(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:02)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "In the event of a Transmission Failure the following reactions, shall be capable of being applied in accordance with a National Value:\n",
+    "\t\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Option 1. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(option(icl>action>thing,equ>choice).@entry,\"1.\")\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall immediately command the emergency brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "agt(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "man(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,immediately(icl>how,com>immediate))\n",
+    "mod(brake(icl>restraint>thing).@def,emergency(icl>crisis>thing))\n",
+    "obj(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,brake(icl>restraint>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The failure shall be shown on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,failure(icl>nonaccomplishment>thing).@def.@topic)\n",
+    "plc(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Option 2. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(option(icl>action>thing,equ>choice).@entry,\"2.\")\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS trainborne equipment shall immediately command the full service brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "agt(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing).@def)\n",
+    "man(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,immediately(icl>how,com>immediate))\n",
+    "mod(brake(icl>restraint>thing).@def,full(icl>adj,ant>empty))\n",
+    "mod(brake(icl>restraint>thing).@def,service(icl>work>action,agt>thing,obj>thing))\n",
+    "obj(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,brake(icl>restraint>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The failure shall be shown on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,failure(icl>nonaccomplishment>thing).@def.@topic)\n",
+    "plc(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Option 3. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(option(icl>action>thing,equ>choice).@entry,\"3.\")\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The train may proceed unrestricted to the end of its movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(proceed_to(icl>begin>do,agt>thing,obj>thing).@entry.@present.@suppose,train(icl>public_transport>thing).@def)\n",
+    "aoj(unrestricted(icl>adj,ant>restricted),train(icl>public_transport>thing).@def)\n",
+    "man(proceed_to(icl>begin>do,agt>thing,obj>thing).@entry.@present.@suppose,unrestricted(icl>adj,ant>restricted))\n",
+    "obj(proceed_to(icl>begin>do,agt>thing,obj>thing).@entry.@present.@suppose,end(icl>moment>time,ant>beginning).@def)\n",
+    "pos(authority(icl>abstract_thing,obj>uw),it(icl>living_thing))\n",
+    "mod(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "agt(end(icl>moment>time,ant>beginning).@def,authority(icl>abstract_thing,obj>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The indication on the DMI shall remain, and the driver shall be informed about the loss of transmission.  \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,indication(icl>communication>thing).@def)\n",
+    "aoj(remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing),indication(icl>communication>thing).@def)\n",
+    "plc(indication(icl>communication>thing).@def,dmi.@def)\n",
+    "and(:01,promise(icl>modal>be,obj>uw,aoj>thing).@entry)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,remain(icl>be,ant>change,obj>uw,aoj>thing,asp>thing))\n",
+    "obj:01(inform(icl>communicate>do,equ>notify,cob>thing,agt>thing,obj>person).@entry.@present.@promise,driver(icl>operator>thing,ant>nondriver).@def.@topic)\n",
+    "cob:01(inform(icl>communicate>do,equ>notify,cob>thing,agt>thing,obj>person).@entry.@present.@promise,loss(icl>failure>thing).@def)\n",
+    "obj:01(loss(icl>failure>thing).@def,transmission(icl>sending>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In the event of a Transmission Failure the following reactions, shall be capable of being applied in accordance with a National Value:. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "scn(promise(icl>modal>be,obj>uw,aoj>thing).@entry,event(icl>psychological_feature>thing).@def)\n",
+    "mod(promise(icl>modal>be,obj>uw,aoj>thing).@entry,transmission(icl>sending>thing).@maiuscul)\n",
+    "nam(transmission(icl>sending>thing).@maiuscul,failure(icl>nonaccomplishment>thing).@maiuscul)\n",
+    "mod(reaction(icl>response>thing).@def.@pl,following(icl>adj,ant>leading))\n",
+    "obj(event(icl>psychological_feature>thing).@def,reaction(icl>response>thing).@def.@pl)\n",
+    "obj:01(be(icl>be).@entry,capable(icl>adj))\n",
+    "man:02(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry,in_accordance_with(icl>how,obj>thing))\n",
+    "mod:02(value(icl>property,obj>thing).@indef.@maiuscul,national(icl>adj,ant>international).@maiuscul)\n",
+    "obj:02(in_accordance_with(icl>how,obj>thing),value(icl>property,obj>thing).@indef.@maiuscul)\n",
+    "obj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "obj:01(capable(icl>adj),:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "If there are failures of the trainborne equipment which compromise the safety of train supervision, the ETCS trainborne equipment shall immediately command the brake and bring the train to a stop.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "If there are failures of the trainborne equipment which compromise the safety of train supervision, the ETCS trainborne equipment shall immediately command the brake and bring the train to a stop. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "con(:01.@_hn-scope,there_is(icl>be,equ>exist,aoj>thing).@entry.@pl.@present)\n",
+    "aoj(there_is(icl>be,equ>exist,aoj>thing).@entry.@pl.@present,failure(icl>nonaccomplishment>thing).@pl)\n",
+    "agt(compromise(icl>do,agt>volitional_thing,ptn>volitional_thing,scn>uw).@present,failure(icl>nonaccomplishment>thing).@pl)\n",
+    "mod(equipment(icl>instrumentality>thing):01.@def,trainborne:01)\n",
+    "obj(failure(icl>nonaccomplishment>thing).@pl,equipment(icl>instrumentality>thing):01.@def)\n",
+    "ptn(compromise(icl>do,agt>volitional_thing,ptn>volitional_thing,scn>uw).@present,safety(icl>condition>thing,ant>danger).@def)\n",
+    "mod(supervision(icl>management>thing),train(icl>public_transport>thing):01)\n",
+    "obj(safety(icl>condition>thing,ant>danger).@def,supervision(icl>management>thing))\n",
+    "mod:01(trainborne:02,etcs)\n",
+    "mod:01(equipment(icl>instrumentality>thing):02.@def,trainborne:02)\n",
+    "agt:01(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,equipment(icl>instrumentality>thing):02.@def)\n",
+    "agt:01(bring(icl>create>do,agt>thing,obj>event,gol>thing).@entry,equipment(icl>instrumentality>thing):02.@def)\n",
+    "man(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,immediately(icl>how,com>immediate))\n",
+    "obj:01(command(icl>lead>do,agt>person,obj>volitional_thing,rec>thing).@entry.@present.@promise,brake(icl>restraint>thing).@def)\n",
+    "obj:01(bring(icl>create>do,agt>thing,obj>event,gol>thing).@entry,train(icl>public_transport>thing):02.@def)\n",
+    "man:01(train(icl>public_transport>thing):02.@def,stop(icl>stay>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The occurrence of a failure shall be displayed on the DMI.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The occurrence of a failure shall be displayed on the DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,occurrence(icl>event>thing,equ>happening).@def.@topic)\n",
+    "obj(occurrence(icl>event>thing,equ>happening).@def.@topic,failure(icl>nonaccomplishment>thing).@indef)\n",
+    "plc(display(icl>show>do,equ>exhibit,agt>thing,obj>thing,rec>thing).@entry.@present.@promise,on)\n",
+    "obj(on,dmi.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "In ETCS with RBC this restriction on performance shall, if possible be transmitted to the RBC.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In ETCS with RBC this restriction on performance shall, if possible be transmitted to the RBC. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(promise(icl>modal>be,obj>uw,aoj>thing).@entry,etcs)\n",
+    "ptn(etcs,rbc(icl>blood_cell>thing,equ>red_blood_cell):01)\n",
+    "mod(restriction(icl>rule>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "aoj(promise(icl>modal>be,obj>uw,aoj>thing).@entry,restriction(icl>rule>thing))\n",
+    "obj(restriction(icl>rule>thing),performance(icl>show>thing))\n",
+    "con(promise(icl>modal>be,obj>uw,aoj>thing).@entry,if(icl>how,obj>uw,con<uw))\n",
+    "mod:01(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@entry,possible(icl>possibility>thing))\n",
+    "ben:01(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@entry,rbc(icl>blood_cell>thing,equ>red_blood_cell):02.@def)\n",
+    "mod(promise(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Describes terms used in the document. The title of a function is normally not described. Please refer to the note below for each function-title.\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Describes terms used in the document. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(describe(icl>inform>do,equ>depict,cob>uw,agt>person,obj>uw,rec>person).@entry.@present,term(icl>word>thing,mod>thing).@pl)\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,term(icl>word>thing,mod>thing).@pl)\n",
+    "plc(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,document(icl>writing>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The title of a function is normally not described. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(describe(icl>inform>do,equ>depict,cob>uw,agt>person,obj>uw,rec>person).@entry.@not.@present,title(icl>heading>thing).@def.@topic)\n",
+    "mod(title(icl>heading>thing).@def.@topic,function(icl>mathematical_relation>thing).@indef)\n",
+    "man(describe(icl>inform>do,equ>depict,cob>uw,agt>person,obj>uw,rec>person).@entry.@not.@present,normally(icl>how))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Please refer to the note below for each function-title. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(refer(icl>relate>be,obj>thing,aoj>information).@entry.@imperative.@request,note(icl>personal_letter>thing).@def)\n",
+    "plc(note(icl>personal_letter>thing).@def,below(icl>how,ant>above))\n",
+    "mod(function(icl>mathematical_relation>thing),each(icl>quantity,per>thing))\n",
+    "and(title(icl>heading>thing),function(icl>mathematical_relation>thing))\n",
+    "man(refer(icl>relate>be,obj>thing,aoj>information).@entry.@imperative.@request,title(icl>heading>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Absolute braking distance\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Absolute braking distance. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(distance(icl>spacing>thing).@entry,absolute(icl>adj,ant>relative))\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,distance(icl>spacing>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Acknowledge\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Acknowledge. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "acknowledge(icl>admit>do,agt>volitional_thing,obj>thing).@entry.@imperative\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Acknowledgement\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Acknowledgement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "acknowledgement(icl>message>thing,equ>acknowledgment).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Advisory information\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Advisory information. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(information(icl>message>thing).@entry,advisory(icl>adj))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Axle counter\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Axle counter. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(counter(icl>table>thing).@entry,axle(icl>shaft>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Balise\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Balise. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "balise.@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Banking\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Banking. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "banking(icl>finance>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Block\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Block. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "block(icl>artifact>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Braking curve\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Braking curve. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,curve(icl>line>thing,ant>straight_line).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Confirm\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Confirm. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "confirm(icl>be,equ>support,obj>uw,aoj>thing,met>thing).@entry.@imperative\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Confirmation\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Confirmation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "confirmation(icl>proof>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Continuous data transmission\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Continuous data transmission. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing),continuous(icl>adj,ant>discontinuous))\n",
+    "mod(transmission(icl>sending>thing).@entry,data(icl>collection>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "CTS\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "CTS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "cts.@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Default value\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Default value. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(value(icl>property,obj>thing).@entry,default(icl>absence>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "DMI\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "DMI. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "dmi.@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Driving \"on sight\"\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Driving \"on sight\". \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@entry,sight(icl>visual_percept>thing).@double_quote)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Dynamic train speed profile\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Dynamic train speed profile. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(train(icl>public_transport>thing),dynamic(icl>adj,ant>undynamic))\n",
+    "mod(speed(icl>rate>thing),train(icl>public_transport>thing))\n",
+    "mod(profile(icl>chart>thing).@entry,speed(icl>rate>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Emergency brake\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Emergency brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(brake(icl>restraint>thing).@entry,emergency(icl>crisis>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "End of movement authority\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "End of movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "agt(end(icl>moment>time,ant>beginning).@entry,authority(icl>abstract_thing,obj>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Equipped line\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Equipped line. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,line(icl>formation>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Exit signal\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Exit signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(signal(icl>communication>thing).@entry,exit(icl>opening>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Fixed block\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Fixed block. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,block(icl>artifact>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Full service brake\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Full service brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(service(icl>work>action,agt>thing,obj>thing),full(icl>adj,ant>empty))\n",
+    "mod(brake(icl>restraint>thing).@entry,service(icl>work>action,agt>thing,obj>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "In advance of\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In advance of. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "scn(of(icl>how,com>quality,obj>thing).@entry,advance(icl>move>process,plt>uw,obj>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Infill information\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Infill information. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(information(icl>message>thing).@entry,infill)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "In rear of\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In rear of. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(in(icl>how,obj>thing,plc<uw).@entry,rear(icl>formation>thing,ant>head))\n",
+    "obj(rear(icl>formation>thing,ant>head),of(icl>how,com>quality,obj>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Interlocking\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Interlocking. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "interlock(icl>organize>do,cob>thing,agt>volitional_thing,obj>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Intermittent transmission\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Intermittent transmission. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(transmission(icl>sending>thing).@entry,intermittent(icl>adj))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Intervention\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Intervention. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "intervention(icl>engagement>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Local Time\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Local Time. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(time(icl>abstract_thing,equ>period).@entry.@maiuscul,local(icl>adj,ant>national))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Main signal\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Main signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(signal(icl>communication>thing).@entry,main(icl>adj,equ>chief))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Movement authority\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@entry,movement(icl>happening>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Moving block\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Moving block. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing).@progress,block(icl>artifact>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Multiple\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Multiple. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "multiple(icl>adj,ant>single).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "National values\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "National values. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(value(icl>property,obj>thing).@entry.@pl,national(icl>adj,ant>international))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Non-equipped line\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Non-equipped line. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,non)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,line(icl>formation>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Odometry\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Odometry. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "odometry.@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Overlap\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Overlap. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "overlap(icl>coincide>be,obj>thing,aoj>thing).@entry.@imperative\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Pantograph\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Pantograph. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "pantograph(icl>mechanical_device>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Permissive signal\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Permissive signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(signal(icl>communication>thing).@entry,permissive(icl>adj,ant>unpermissive))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Permitted speed\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Permitted speed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@state,speed(icl>rate>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Propelling\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Propelling. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "propel(icl>move>do,agt>thing,obj>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Railway management system\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Railway management system. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(management(icl>action,agt>volitional_thing,obj>thing),railway(icl>line>thing))\n",
+    "mod(system(icl>group>thing).@entry,management(icl>action,agt>volitional_thing,obj>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "RBC\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "RBC. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "rbc(icl>blood_cell>thing,equ>red_blood_cell).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Reference point\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Reference point. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(point(icl>component>thing).@entry,reference(icl>remark>thing,equ>mention))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Relative braking distance\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Relative braking distance. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,relative(icl>person>thing))\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,distance(icl>spacing>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Release speed\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Release speed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(speed(icl>rate>thing).@entry,release(icl>merchandise>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Reversing\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Reversing. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "reverse(icl>change>do,agt>thing,obj>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Route\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Route. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "route(icl>line>thing,equ>path).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Route map\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Route map. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(map(icl>representation>thing).@entry,route(icl>line>thing,equ>path))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Safety distance\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Safety distance. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(distance(icl>spacing>thing).@entry,safety(icl>condition>thing,ant>danger))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Shunt hauling\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Shunt hauling. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(haul(icl>draw(icl>move)>do,agt>thing,obj>concrete_thing).@entry,shunt(icl>passage>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Shunt propelling\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Shunt propelling. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(propel(icl>move>do,agt>thing,obj>thing).@entry,shunt(icl>passage>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Shunting movement\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Shunting movement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing).@progress,movement(icl>happening>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Shunting signal\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Shunting signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing).@progress,signal(icl>communication>thing).@entry)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "SRS\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "SRS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "srs.@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Static speed profile\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Static speed profile. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(profile(icl>chart>thing).@entry,static(icl>adj,equ>inactive))\n",
+    "mod(profile(icl>chart>thing).@entry,speed(icl>rate>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Station\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Station. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "station(icl>facility>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "STM\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "STM. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "stm.@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Stop signal\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Stop signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(signal(icl>communication>thing).@entry,stop(icl>stay>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "SSRS\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "SSRS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "ssr.@entry.@pl\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Tandem\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Tandem. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "tandem(icl>bicycle>thing,equ>bicycle-built-for-two).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Target\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Target. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "target(icl>reference_point>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Temporary speed restriction\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Temporary speed restriction. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(restriction(icl>rule>thing).@entry,temporary(icl>adj,equ>impermanent,ant>permanent))\n",
+    "mod(restriction(icl>rule>thing).@entry,speed(icl>rate>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Traction unit\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Traction unit. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@entry,traction(icl>pull>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track circuit\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track circuit. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(circuit(icl>electrical_device>thing).@entry,track(icl>line>thing,equ>path))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track free\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track free. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(free(icl>adj,ant>unfree).@entry,track(icl>line>thing,equ>path))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track occupied\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track occupied. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@entry.@past,track(icl>line>thing,equ>path))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track-to-train transmission\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track-to-train transmission. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(transmission(icl>sending>thing).@entry,track(icl>line>thing,equ>path))\n",
+    "plt(track(icl>line>thing,equ>path),train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "train(icl>public_transport>thing).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train data\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train data. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@entry,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train memory\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train memory. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(memory(icl>basic_cognitive_process>thing).@entry,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train movement\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train movement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(movement(icl>happening>thing).@entry,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train-to-track transmission\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train-to-track transmission. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "pur(train(icl>public_transport>thing).@entry,track(icl>mark>do,agt>thing,obj>thing))\n",
+    "obj(track(icl>mark>do,agt>thing,obj>thing),transmission(icl>sending>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Train trip\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Train trip. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trip(icl>journey>thing).@entry,train(icl>public_transport>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Warning\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Warning. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "warn(icl>notify_of_danger>do,cob>uw,agt>person,obj>person).@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Wheelslip\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Wheelslip. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "wheelslip.@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Wheelslide\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Wheelslide. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "[W]\n",
+    "wheelslide.@entry\n",
+    "[/W]\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The distance between a train following another train shall be equal to or greater than the braking distance of the following train.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The distance between a train following another train shall be equal to or greater than the braking distance of the following train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(distance(icl>spacing>thing):01.@entry.@def,between(icl>how,obj>thing,plc<uw))\n",
+    "obj(between(icl>how,obj>thing,plc<uw),train(icl>public_transport>thing):01.@indef)\n",
+    "agt(follow(icl>move>do,equ>go_after,agt>volitional_thing,obj>volitional_thing).@progress,train(icl>public_transport>thing):01.@indef)\n",
+    "obj(follow(icl>move>do,equ>go_after,agt>volitional_thing,obj>volitional_thing).@progress,another(icl>adj,equ>another))\n",
+    "mod(train(icl>public_transport>thing):02,another(icl>adj,equ>another))\n",
+    "aoj(equal(icl>adj,ant>unequal).@present.@promise,train(icl>public_transport>thing):02)\n",
+    "or(train(icl>practice>do,agt>person,obj>person,gol>uw),equal(icl>adj,ant>unequal).@present.@promise)\n",
+    "to(equal(icl>adj,ant>unequal).@present.@promise,to(icl>how,to<uw,obj>thing))\n",
+    "man(train(icl>practice>do,agt>person,obj>person,gol>uw),greatly(icl>how,com>great))\n",
+    "bas(greatly(icl>how,com>great),distance(icl>spacing>thing):02.@def)\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,distance(icl>spacing>thing):02.@def)\n",
+    "obj(distance(icl>spacing>thing):02.@def,following(icl>adj,ant>leading).@def)\n",
+    "man(greatly(icl>how,com>great),more(icl>how))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "New data/situation that the driver has to accept to avoid intervention.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "New data/situation that the driver has to accept to avoid intervention. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@entry,new(icl>adj,ant>old))\n",
+    "mod(situation(icl>state>abstract_thing,obj>thing,aoj>thing),new(icl>adj,ant>old))\n",
+    "or(situation(icl>state>abstract_thing,obj>thing,aoj>thing),data(icl>collection>thing).@entry)\n",
+    "obj(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@present.@obligation-strong,situation(icl>state>abstract_thing,obj>thing,aoj>thing))\n",
+    "aoj(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@present.@obligation-strong,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "pur(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@present.@obligation-strong,avoid(icl>prevent>do,agt>thing,obj>abstract_thing))\n",
+    "obj(avoid(icl>prevent>do,agt>thing,obj>abstract_thing),intervention(icl>engagement>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "New data/situation that the driver has to accept to avoid intervention.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "New data/situation that the driver has to accept to avoid intervention. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(data(icl>collection>thing).@entry,new(icl>adj,ant>old))\n",
+    "mod(situation(icl>state>abstract_thing,obj>thing,aoj>thing),new(icl>adj,ant>old))\n",
+    "or(situation(icl>state>abstract_thing,obj>thing,aoj>thing),data(icl>collection>thing).@entry)\n",
+    "obj(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@present.@obligation-strong,situation(icl>state>abstract_thing,obj>thing,aoj>thing))\n",
+    "aoj(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@present.@obligation-strong,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "pur(accept(icl>evaluate>be,equ>consider_true,src>thing,obj>information,aoj>person).@present.@obligation-strong,avoid(icl>prevent>do,agt>thing,obj>abstract_thing))\n",
+    "obj(avoid(icl>prevent>do,agt>thing,obj>abstract_thing),intervention(icl>engagement>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Information indicated to the driver on the DMI to assist him in driving the train.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Information indicated to the driver on the DMI to assist him in driving the train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@past,information(icl>message>thing))\n",
+    "agt(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@past,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "plc(driver(icl>operator>thing,ant>nondriver).@def,dmi.@def)\n",
+    "ben:01(assist(icl>do,equ>aid,agt>person,ben>person,met>thing,scn>thing).@entry,he(icl>person))\n",
+    "obj:02(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@entry,train(icl>public_transport>thing).@def)\n",
+    "pur(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@entry.@past,:01)\n",
+    "scn:01(assist(icl>do,equ>aid,agt>person,ben>person,met>thing,scn>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A method of &#8220;train detection&#8221;. Track mounted equipment counts he number of axles entering and leaving a track section at each extremity. A calculation is performed to determine whether the track section is &#8220;occupied&#8221; or clear.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A method of \"train detection\". \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(detection(icl>perception>thing).@entry,train(icl>public_transport>thing))\n",
+    "obj(method(icl>know-how>thing).@entry.@indef,:01.@double_quote)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track mounted equipment counts he number of axles entering and leaving a track section at each extremity. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(count(icl>do,equ>calculate,agt>thing,obj>thing).@present,track(icl>line>thing,equ>path):01)\n",
+    "mod(he(icl>person).@entry,track(icl>line>thing,equ>path):01)\n",
+    "obj(mount(icl>attach>do,agt>thing,obj>thing).@state,equipment(icl>instrumentality>thing))\n",
+    "agt(count(icl>do,equ>calculate,agt>thing,obj>thing).@present,equipment(icl>instrumentality>thing))\n",
+    "fictit(he(icl>person).@entry,number(icl>abstract_thing,icl>quantity,obj>thing))\n",
+    "obj(number(icl>abstract_thing,icl>quantity,obj>thing),axle(icl>shaft>thing).@pl)\n",
+    "agt(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@continue,axle(icl>shaft>thing).@pl)\n",
+    "agt(leave(icl>refrain>do,agt>thing,obj>thing,asp>thing),axle(icl>shaft>thing).@pl)\n",
+    "obj(leave(icl>refrain>do,agt>thing,obj>thing,asp>thing),track(icl>line>thing,equ>path):02.@indef)\n",
+    "mod:01(extremity(icl>region>thing),each(icl>quantity,per>thing))\n",
+    "tim:01(section(icl>divide>do,agt>thing,obj>thing,per>thing).@entry,extremity(icl>region>thing))\n",
+    "mod(axle(icl>shaft>thing).@pl,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A calculation is performed to determine whether the track section is \"occupied\" or clear. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(perform(icl>do,agt>thing,obj>thing).@entry.@present,calculation(icl>procedure>thing).@indef.@topic)\n",
+    "mod:02(section(icl>writing>thing).@def.@topic,track(icl>line>thing,equ>path))\n",
+    "obj:02(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@entry.@present.@double_quote,section(icl>writing>thing).@def.@topic)\n",
+    "pur(perform(icl>do,agt>thing,obj>thing).@entry.@present,clear(icl>brighten>occur,cob>concrete_thing,obj>space>thing))\n",
+    "or(clear(icl>brighten>occur,cob>concrete_thing,obj>space>thing),:01)\n",
+    "obj:01(determine(icl>cause>be,equ>shape,obj>thing,aoj>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Device used for intermittent transmission between track and train and/or train and track.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Device used for intermittent transmission between track and train and/or train and track. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,device(icl>instrumentality>thing).@entry)\n",
+    "mod(transmission(icl>sending>thing),intermittent(icl>adj))\n",
+    "pur(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,transmission(icl>sending>thing))\n",
+    "plc(transmission(icl>sending>thing),between(icl>how,obj>thing,plc<uw))\n",
+    "and(train(icl>public_transport>thing):01,track(icl>line>thing,equ>path):01)\n",
+    "and(and or,train(icl>public_transport>thing):01)\n",
+    "obj(between(icl>how,obj>thing,plc<uw),and or)\n",
+    "and(track(icl>line>thing,equ>path):02,train(icl>public_transport>thing):02)\n",
+    "obj(and or,track(icl>line>thing,equ>path):02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "An additional traction unit at the rear end of the train, not coupled, supporting the train for moving up a hill, leaving the train on top whilst running.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "An additional traction unit at the rear end of the train, not coupled, supporting the train for moving up a hill, leaving the train on top whilst running. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@indef,additional(icl>adj,equ>extra))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@indef,traction(icl>pull>thing))\n",
+    "agt(couple(icl>join>do,equ>match,cob>thing,agt>thing,obj>thing).@entry.@past.@not,unit(icl>measure>abstract_thing,aoj>uw).@indef)\n",
+    "mod(end(icl>moment>time,ant>beginning).@def,rear(icl>adj,equ>rear))\n",
+    "tim(unit(icl>measure>abstract_thing,aoj>uw).@indef,end(icl>moment>time,ant>beginning).@def)\n",
+    "obj(end(icl>moment>time,ant>beginning).@def,train(icl>public_transport>thing):01.@def)\n",
+    "obj:01(support(icl>help>do,agt>thing,obj>person,met>thing,scn>uw).@entry,train(icl>public_transport>thing):02.@def)\n",
+    "plt:02(move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing).@entry,up(icl>how,com>height))\n",
+    "obj:02(move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing).@entry,hill(icl>natural_elevation>thing).@indef)\n",
+    "mod:02(hill(icl>natural_elevation>thing).@indef,leave on.@progress)\n",
+    "obj:02(leave on.@progress,train(icl>public_transport>thing):03.@def)\n",
+    "aoj:02(top(icl>adj),train(icl>public_transport>thing):03.@def)\n",
+    "man:02(leave on.@progress,top(icl>adj))\n",
+    "tim:02(leave on.@progress,whilst(icl>how,equ>while,tim<uw,obj>uw))\n",
+    "obj:02(whilst(icl>how,equ>while,tim<uw,obj>uw),run(icl>go>do,plt>uw,plf>uw,agt>thing))\n",
+    "man(couple(icl>join>do,equ>match,cob>thing,agt>thing,obj>thing).@entry.@past.@not,:01)\n",
+    "pur:01(train(icl>public_transport>thing):02.@def,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A method of controlling the separation between trains by dividing the line into sections with, normally, no more than one train in each section. The block can either be a fixed block or a moving block.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A method of controlling the separation between trains by dividing the line into sections with, normally, no more than one train in each section. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(method(icl>know-how>thing).@entry.@indef,control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing))\n",
+    "obj(control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing),separation(icl>change_of_integrity>thing).@def)\n",
+    "plc(separation(icl>change_of_integrity>thing).@def,between(icl>how,obj>thing,plc<uw))\n",
+    "obj(between(icl>how,obj>thing,plc<uw),train(icl>public_transport>thing):01.@pl)\n",
+    "met(control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing),divide(icl>change>do,equ>separate,agt>thing,obj>thing,gol>thing,ins>thing))\n",
+    "obj(divide(icl>change>do,equ>separate,agt>thing,obj>thing,gol>thing,ins>thing),line(icl>formation>thing).@def)\n",
+    "gol(divide(icl>change>do,equ>separate,agt>thing,obj>thing,gol>thing,ins>thing),section(icl>writing>thing):01.@pl)\n",
+    "man(no,normally(icl>how).@parenth)\n",
+    "ins(divide(icl>change>do,equ>separate,agt>thing,obj>thing,gol>thing,ins>thing),no)\n",
+    "mod(no,more(icl>how))\n",
+    "qua(train(icl>public_transport>thing):02,one(icl>digit>thing))\n",
+    "bas(more(icl>how),train(icl>public_transport>thing):02)\n",
+    "mod(section(icl>writing>thing):02,each(icl>quantity,per>thing))\n",
+    "plc(train(icl>public_transport>thing):02,section(icl>writing>thing):02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The block can either be a fixed block or a moving block. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(block(icl>artifact>thing):02.@entry.@indef.@present.@ability,block(icl>artifact>thing):01.@def)\n",
+    "obj(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,block(icl>artifact>thing):02.@entry.@indef.@present.@ability)\n",
+    "obj(either_or(icl>how,equ>or,com>two_options,obj>uw,or<uw),block(icl>artifact>thing):02.@entry.@indef.@present.@ability)\n",
+    "or(block(icl>artifact>thing):03.@indef,either_or(icl>how,equ>or,com>two_options,obj>uw,or<uw))\n",
+    "obj(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing).@progress,block(icl>artifact>thing):03.@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A speed-distance curve calculated from train and infrastructure data and deceleration parameters of the train.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A speed-distance curve calculated from train and infrastructure data and deceleration parameters of the train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(distance(icl>spacing>thing),speed(icl>rate>thing))\n",
+    "mod(curve(icl>line>thing,ant>straight_line).@entry.@indef,distance(icl>spacing>thing))\n",
+    "obj(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@state,curve(icl>line>thing,ant>straight_line).@entry.@indef)\n",
+    "mod(train(icl>public_transport>thing):01.@entry,infrastructure(icl>structure>thing))\n",
+    "and:03(parameter(icl>constant>thing).@entry.@pl,data(icl>collection>thing).@entry)\n",
+    "mod(parameter(icl>constant>thing).@entry.@pl,deceleration(icl>change>thing,ant>acceleration))\n",
+    "obj:03(parameter(icl>constant>thing).@entry.@pl,train(icl>public_transport>thing):02.@def)\n",
+    "plf(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@state,:03.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver&#8217;s approval/validation that new data/information shall be taken into account by the system.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver's approval/validation that new data/information shall be taken into account by the system. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or(validation(icl>determination>thing),approval(icl>support>thing,equ>blessing,ant>disapproval))\n",
+    "mod(:01.@_hn-scope,validation(icl>determination>thing))\n",
+    "mod:01(data(icl>collection>thing).@entry.@topic,that(icl>determiner>adj,com>remote,mod<concrete_thing))\n",
+    "mod:01(data(icl>collection>thing).@entry.@topic,new(icl>adj,ant>old))\n",
+    "or:01(information(icl>message>thing).@entry,data(icl>collection>thing).@entry.@topic)\n",
+    "pos:01(data(icl>collection>thing).@entry.@topic,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "plt(take(icl>require>be,obj>thing,aoj>thing,ben>person).@entry.@present.@promise,account(icl>agreement(icl>abstract_thing)))\n",
+    "aoj(take(icl>require>be,obj>thing,aoj>thing,ben>person).@entry.@present.@promise,system(icl>group>thing).@def)\n",
+    "obj(take(icl>require>be,obj>thing,aoj>thing,ben>person).@entry.@present.@promise,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver&#8217;s approval/validation that new data/information shall be taken into account by the system.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver's approval/validation that new data/information shall be taken into account by the system. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or(validation(icl>determination>thing),approval(icl>support>thing,equ>blessing,ant>disapproval))\n",
+    "mod(:01.@_hn-scope,validation(icl>determination>thing))\n",
+    "mod:01(data(icl>collection>thing).@entry.@topic,that(icl>determiner>adj,com>remote,mod<concrete_thing))\n",
+    "mod:01(data(icl>collection>thing).@entry.@topic,new(icl>adj,ant>old))\n",
+    "or:01(information(icl>message>thing).@entry,data(icl>collection>thing).@entry.@topic)\n",
+    "pos:01(data(icl>collection>thing).@entry.@topic,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "plt(take(icl>require>be,obj>thing,aoj>thing,ben>person).@entry.@present.@promise,account(icl>agreement(icl>abstract_thing)))\n",
+    "aoj(take(icl>require>be,obj>thing,aoj>thing,ben>person).@entry.@present.@promise,system(icl>group>thing).@def)\n",
+    "obj(take(icl>require>be,obj>thing,aoj>thing,ben>person).@entry.@present.@promise,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track-to-train or train-to-track transmission can take place continuously via long loop or radio. The information is dedicated by a unique ETCS identifier.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track-to-train or train-to-track transmission can take place continuously via long loop or radio. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or(transmission(icl>sending>thing),track(icl>line>thing,equ>path):01)\n",
+    "pur(track(icl>line>thing,equ>path):01,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "mod(transmission(icl>sending>thing),train(icl>public_transport>thing))\n",
+    "to(train(icl>public_transport>thing),track(icl>line>thing,equ>path):02)\n",
+    "aoj(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@entry.@present.@ability,transmission(icl>sending>thing))\n",
+    "obj(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@entry.@present.@ability,place(icl>space>thing,equ>seat))\n",
+    "man(place(icl>space>thing,equ>seat),continuously(icl>how,com>continuous))\n",
+    "mod(:01.@_hn-scope,long(icl>adj,ant>short))\n",
+    "or:01(radio(icl>media>abstract_thing).@entry,loop(icl>fastener>thing,equ>cringle).@entry)\n",
+    "via(place(icl>space>thing,equ>seat),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The information is dedicated by a unique ETCS identifier. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(dedicate(icl>give>do,equ>devote,agt>person,obj>thing,ben>uw).@entry.@present,information(icl>message>thing).@def.@topic)\n",
+    "mod(identifier(icl>symbol>thing).@indef,unique(icl>adj,equ>alone))\n",
+    "mod(identifier(icl>symbol>thing).@indef,etcs)\n",
+    "agt(dedicate(icl>give>do,equ>devote,agt>person,obj>thing,ben>uw).@entry.@present,identifier(icl>symbol>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Centralized Train Signalling. movement authorities and possibly static train profiles are calculated in the CTS and transmitted to the train via ETCS.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Centralized Train Signalling. movement authorities and possibly static train profiles are calculated in the CTS and transmitted to the train via ETCS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(profile(icl>chart>thing).@pl,train(icl>public_transport>thing):01.@topic.@maiuscul)\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@pl,movement(icl>happening>thing))\n",
+    "obj(signal(icl>signalize>do,agt>person,obj>thing,rec>person).@progress.@maiuscul,authority(icl>abstract_thing,obj>uw).@pl)\n",
+    "man(train(icl>public_transport>thing):01.@topic.@maiuscul,possibly(icl>how).@parenth)\n",
+    "mod(train(icl>public_transport>thing):02,static(icl>adj,equ>inactive))\n",
+    "mod(profile(icl>chart>thing).@pl,train(icl>public_transport>thing):02)\n",
+    "obj(centralize(icl>change>occur,obj>thing).@state,profile(icl>chart>thing).@pl)\n",
+    "agt(signal(icl>signalize>do,agt>person,obj>thing,rec>person).@progress.@maiuscul,profile(icl>chart>thing).@pl)\n",
+    "obj(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@pl.@present,profile(icl>chart>thing).@pl)\n",
+    "and(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@pl.@present,calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@pl.@present)\n",
+    "plc(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry.@pl.@present,cts.@def)\n",
+    "plc(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@pl.@present,cts.@def)\n",
+    "mod(via.@def,train(icl>public_transport>thing):03)\n",
+    "ben(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@pl.@present,via.@def)\n",
+    "nam(via.@def,etcs)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Value stored in the ETCS trainborne equipment and used if there is no other value being available.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Value stored in the ETCS trainborne equipment and used if there is no other value being available. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@state,value(icl>property,obj>thing):01.@entry)\n",
+    "and(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw),store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@state)\n",
+    "mod(trainborne,etcs)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,trainborne)\n",
+    "plc(store(icl>keep>do,agt>thing,obj>concrete_thing,plc>place).@state,equipment(icl>instrumentality>thing).@def)\n",
+    "plc(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw),equipment(icl>instrumentality>thing).@def)\n",
+    "mod:01(value(icl>property,obj>thing):02,no(icl>quantity,qua<thing))\n",
+    "mod:01(value(icl>property,obj>thing):02,other(icl>adj,equ>different))\n",
+    "aoj:01(there_is(icl>be,equ>exist,aoj>thing).@entry.@present.@progress,value(icl>property,obj>thing):02)\n",
+    "obj:01(there_is(icl>be,equ>exist,aoj>thing).@entry.@present.@progress,available(icl>adj,ant>unavailable))\n",
+    "con(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Driver Machine Interface. The trainborne device indicating ETCS information to the driver and used by the driver for operating ETCS.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Driver Machine Interface. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(machine(icl>device>thing).@maiuscul,driver(icl>operator>thing,ant>nondriver))\n",
+    "mod(interface(icl>surface>thing).@entry.@maiuscul,machine(icl>device>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The trainborne device indicating ETCS information to the driver and used by the driver for operating ETCS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(device(icl>instrumentality>thing),trainborne)\n",
+    "aoj(indicate(icl>mean>be,equ>betoken,obj>uw,aoj>uw).@progress,device(icl>instrumentality>thing))\n",
+    "mod(etcs:01,device(icl>instrumentality>thing))\n",
+    "mod(information(icl>message>thing).@entry.@def,etcs:01)\n",
+    "mod(information(icl>message>thing).@entry.@def,to(icl>how,com>content,obj>thing))\n",
+    "and(:01,driver(icl>operator>thing,ant>nondriver):01.@def)\n",
+    "agt:01(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry,driver(icl>operator>thing,ant>nondriver):02.@def)\n",
+    "obj:02(operate(icl>manage>do,agt>volitional_thing,obj>thing).@entry,etcs:02)\n",
+    "obj(to(icl>how,com>content,obj>thing),:01)\n",
+    "pur:01(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The driver has to drive at a speed he is able to stop the train or the shunting movement respecting any obstacle on the track that may violate his vehicle(s).\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The driver has to drive at a speed he is able to stop the train or the shunting movement respecting any obstacle on the track that may violate his vehicle(s). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "agt(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "obj(obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry,drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing))\n",
+    "mod:01(he(icl>person):01,speed(icl>rate>thing).@entry.@indef)\n",
+    "aoj:01(stop(icl>cease>do,agt>volitional_thing,obj>action).@present.@ability,he(icl>person):01)\n",
+    "or:04(obstacle(icl>hindrance>thing).@entry,train(icl>public_transport>thing).@entry.@def)\n",
+    "aoj:03(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@entry,movement(icl>happening>thing))\n",
+    "mod(:04.@_hn-scope,any(icl>adj))\n",
+    "obj(stop(icl>cease>do,agt>volitional_thing,obj>action).@present.@ability,obstacle(icl>hindrance>thing).@entry)\n",
+    "aoj(violate(icl>be,obj>thing,aoj>thing).@present.@suppose,track(icl>line>thing,equ>path).@def)\n",
+    "pos(vehicle(icl>functional_thing,pur>thing),he(icl>person):02)\n",
+    "obj(violate(icl>be,obj>thing,aoj>thing).@present.@suppose,vehicle(icl>functional_thing,pur>thing))\n",
+    "cnt(vehicle(icl>functional_thing,pur>thing),s.@parenthesis)\n",
+    "plc:04(obstacle(icl>hindrance>thing).@entry,:01)\n",
+    "mod(obligation-strong(icl>modal>be,obj>uw,aoj>thing).@entry,:02)\n",
+    "obj:02(shunt(icl>transfer>do,agt>thing,obj>thing).@entry,:03)\n",
+    "tim(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing),:04.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The speed-distance curve which a train may follow without violating the static train speed profile and the end of movement authority. This curve depends on the braking characteristics of the train and the train length.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The speed-distance curve which a train may follow without violating the static train speed profile and the end of movement authority. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(distance(icl>spacing>thing),speed(icl>rate>thing):01)\n",
+    "mod(curve(icl>line>thing,ant>straight_line).@entry.@def,distance(icl>spacing>thing))\n",
+    "obj(follow(icl>move>do,equ>go_after,agt>volitional_thing,obj>volitional_thing).@present.@suppose,curve(icl>line>thing,ant>straight_line).@entry.@def)\n",
+    "agt(follow(icl>move>do,equ>go_after,agt>volitional_thing,obj>volitional_thing).@present.@suppose,train(icl>public_transport>thing):01.@indef)\n",
+    "man(follow(icl>move>do,equ>go_after,agt>volitional_thing,obj>volitional_thing).@present.@suppose,without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing),violate(icl>be,obj>thing,aoj>thing))\n",
+    "mod(train(icl>public_transport>thing):02,static(icl>adj,equ>inactive))\n",
+    "mod(speed(icl>rate>thing):02,train(icl>public_transport>thing):02)\n",
+    "mod(:01.@_hn-scope,speed(icl>rate>thing):02)\n",
+    "and:01(end(icl>moment>time,ant>beginning).@entry.@def,profile(icl>chart>thing).@entry.@def)\n",
+    "mod:01(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "agt:01(end(icl>moment>time,ant>beginning).@entry.@def,authority(icl>abstract_thing,obj>uw))\n",
+    "obj(violate(icl>be,obj>thing,aoj>thing),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "This curve depends on the braking characteristics of the train and the train length. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(curve(icl>line>thing,ant>straight_line),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "aoj(depend(icl>be,com>condition,obj>thing,aoj>thing).@entry.@present,curve(icl>line>thing,ant>straight_line))\n",
+    "and(length(icl>fundamental_quantity>thing).@def,characteristic(icl>property>thing,equ>feature).@def.@pl)\n",
+    "mod(characteristic(icl>property>thing,equ>feature).@def.@pl,train(icl>public_transport>thing):01.@def)\n",
+    "mod(length(icl>fundamental_quantity>thing).@def,train(icl>public_transport>thing):02)\n",
+    "obj(depend(icl>be,com>condition,obj>thing,aoj>thing).@entry.@present,length(icl>fundamental_quantity>thing).@def)\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,length(icl>fundamental_quantity>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "As defined in UIC leaflet 541-03. All emergency brake applications initiated by ETCS may be released by the driver according to a national value except in the case of applying to train trip\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "As defined in UIC leaflet 541-03. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw).@entry,define(icl>characterize>be,obj>uw,aoj>thing).@past)\n",
+    "mod(leaflet(icl>flap>thing,equ>cusp),uic)\n",
+    "plc(define(icl>characterize>be,obj>uw,aoj>thing).@past,leaflet(icl>flap>thing,equ>cusp))\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@past,541)\n",
+    "fmt(541,\"03.\")\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "All emergency brake applications initiated by ETCS may be released by the driver according to a national value except in the case of applying to train trip. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@past,all(icl>quantity,ant>some,per>thing))\n",
+    "qua(grant(icl>modal>be,obj>uw,aoj>thing).@entry,all(icl>quantity,ant>some,per>thing))\n",
+    "man(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@past,except(icl>how,obj>thing))\n",
+    "obj(except(icl>how,obj>thing),which)\n",
+    "mod(brake(icl>restraint>thing),emergency(icl>crisis>thing))\n",
+    "mod(application(icl>information,equ>request,agt>thing,obj>uw).@pl,brake(icl>restraint>thing))\n",
+    "agt(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@past,application(icl>information,equ>request,agt>thing,obj>uw).@pl)\n",
+    "met(initiate(icl>start>do,agt>volitional_thing,obj>thing,scn>thing).@past,etcs)\n",
+    "obj:01(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "src:01(driver(icl>operator>thing,ant>nondriver).@def,according_to(icl>how,src>uw,obj>uw))\n",
+    "mod:01(value(icl>property,obj>thing).@indef,national(icl>adj,ant>international))\n",
+    "obj:01(according_to(icl>how,src>uw,obj>uw),value(icl>property,obj>thing).@indef)\n",
+    "scn(grant(icl>modal>be,obj>uw,aoj>thing).@entry,case(icl>happening>thing).@def)\n",
+    "pur:02(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "obj:02(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing).@entry,trip(icl>journey>thing))\n",
+    "obj(grant(icl>modal>be,obj>uw,aoj>thing).@entry,:01)\n",
+    "obj(case(icl>happening>thing).@def,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Location to which the train is permitted to proceed and where target speed = zero.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Location to which the train is permitted to proceed and where target speed = zero. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "cob(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@present,location(icl>object>thing).@entry)\n",
+    "agt(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@present,train(icl>public_transport>thing).@def)\n",
+    "and:01(target(icl>intend>do,agt>thing,obj>thing).@entry,proceed(icl>talk>do,equ>continue,plf>thing,agt>person,obj>action).@entry)\n",
+    "plc(:01.@_hn-scope,where(icl>how,plc<uw))\n",
+    "mod:01(=,speed(icl>rate>thing))\n",
+    "mod:01(zero(icl>abstract_thing,equ>nothing),=)\n",
+    "obj:01(target(icl>intend>do,agt>thing,obj>thing).@entry,zero(icl>abstract_thing,equ>nothing))\n",
+    "obj(permit(icl>accept>do,agt>thing,obj>thing,rec>thing).@present,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Trackside ETCS equipment installed to provide Full Supervision .\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Trackside ETCS equipment installed to provide Full Supervision . \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(etcs,trackside)\n",
+    "mod(equipment(icl>instrumentality>thing),etcs)\n",
+    "agt(install(icl>set_up>do,plt>thing,agt>volitional_thing,obj>concrete_thing).@entry.@past,equipment(icl>instrumentality>thing))\n",
+    "mod:01(supervision(icl>management>thing).@maiuscul,full(icl>adj,ant>empty).@maiuscul)\n",
+    "obj:01(provide(icl>equip>do,cob>thing,obj>thing).@entry,supervision(icl>management>thing).@maiuscul)\n",
+    "pur(install(icl>set_up>do,plt>thing,agt>volitional_thing,obj>concrete_thing).@entry.@past,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Main signal, intended for trains leaving a station.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Main signal, intended for trains leaving a station. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(signal(icl>communication>thing).@entry,main(icl>adj,equ>chief))\n",
+    "pur:01(intend(icl>do,equ>predestinate,agt>volitional_thing,obj>thing,rec>volitional_thing).@entry,train(icl>public_transport>thing).@pl)\n",
+    "agt(leave(icl>refrain>do,agt>thing,obj>thing,asp>thing).@progress,train(icl>public_transport>thing).@pl)\n",
+    "obj(leave(icl>refrain>do,agt>thing,obj>thing,asp>thing).@progress,station(icl>facility>thing).@indef)\n",
+    "mod(signal(icl>communication>thing).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A block in which the extremities of the block sections are fixed. The signalling allows a train to move from one block to the next, normally only when the block ahead is clear.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A block in which the extremities of the block sections are fixed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@pl.@present,block(icl>artifact>thing):01.@entry.@indef)\n",
+    "obj(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@pl.@present,extremity(icl>region>thing).@def.@pl.@topic)\n",
+    "mod(section(icl>writing>thing).@def.@pl,block(icl>artifact>thing):02)\n",
+    "obj(extremity(icl>region>thing).@def.@pl.@topic,section(icl>writing>thing).@def.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The signalling allows a train to move from one block to the next, normally only when the block ahead is clear. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry.@present,signal(icl>signalize>do,agt>person,obj>thing,rec>person).@def)\n",
+    "ben(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry.@present,train(icl>public_transport>thing).@indef)\n",
+    "obj(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry.@present,move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing))\n",
+    "qua(block(icl>artifact>thing):01,one(icl>digit>thing))\n",
+    "plf(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing),block(icl>artifact>thing):01)\n",
+    "plt(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing),next(icl>adj,equ>adjacent).@def)\n",
+    "man(only(icl>how,equ>merely),normally(icl>how))\n",
+    "tim(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing),only(icl>how,equ>merely))\n",
+    "obj(move(icl>occur,equ>displace,plt>thing,plf>thing,obj>thing),block(icl>artifact>thing):02.@def)\n",
+    "aoj(clear(icl>adj,ant>unclear).@present,block(icl>artifact>thing):02.@def)\n",
+    "mod(block(icl>artifact>thing):02.@def,ahead(icl>how,ant>back))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "As defined in UIC leaflet 541-03. May be released by the driver at any time.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "As defined in UIC leaflet 541-03. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw).@entry,define(icl>characterize>be,obj>uw,aoj>thing).@past)\n",
+    "mod(leaflet(icl>flap>thing,equ>cusp),uic)\n",
+    "plc(define(icl>characterize>be,obj>uw,aoj>thing).@past,leaflet(icl>flap>thing,equ>cusp))\n",
+    "obj(define(icl>characterize>be,obj>uw,aoj>thing).@past,541)\n",
+    "fmt(541,\"03.\")\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "May be released by the driver at any time. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "met(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry.@present.@grant,driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod(time(icl>abstract_thing,equ>occasion),any(icl>adj))\n",
+    "tim(driver(icl>operator>thing,ant>nondriver).@def,time(icl>abstract_thing,equ>occasion))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "B is said to be in advance of A if a train would pass A before B in the direction of travel.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "B is said to be in advance of A if a train would pass A before B in the direction of travel. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(b-initial.@entry,say(icl>communicate>do,equ>tell,agt>person,obj>uw,cao>thing,rec>volitional_thing).@present)\n",
+    "scn(say(icl>communicate>do,equ>tell,agt>person,obj>uw,cao>thing,rec>volitional_thing).@present,advance(icl>move>process,plt>uw,obj>thing))\n",
+    "agt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present.@probable,train(icl>public_transport>thing).@indef)\n",
+    "con(b-initial.@entry,pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present.@probable)\n",
+    "plc(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@present.@probable,a)\n",
+    "plc(a,before(icl>how,obj>thing,plc<uw))\n",
+    "obj(before(icl>how,obj>thing,plc<uw),b)\n",
+    "plc(b,direction(icl>path>thing).@def)\n",
+    "obj(direction(icl>path>thing).@def,travel(icl>motion>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Data which is transmitted from track-to-train at locations other than at main signals. Provides, for example, the ability to inform a train that the signal ahead has cleared.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Data which is transmitted from track-to-train at locations other than at main signals. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@present,data(icl>collection>thing))\n",
+    "mod(track(icl>line>thing,equ>path).@entry,data(icl>collection>thing))\n",
+    "obj(train(icl>practice>do,agt>person,obj>person,gol>uw),which)\n",
+    "frm(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@present,from(icl>how,obj>thing,frm<uw))\n",
+    "pur(track(icl>line>thing,equ>path).@entry,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "plc(train(icl>practice>do,agt>person,obj>person,gol>uw),location(icl>object>thing).@pl)\n",
+    "mod(location(icl>object>thing).@pl,other(icl>adj,equ>different))\n",
+    "bas(other(icl>adj,equ>different),than(icl>how,equ>but_not,obj>uw,bas<thing))\n",
+    "mod(signal(icl>communication>thing).@pl,main(icl>adj,equ>chief))\n",
+    "plc(than(icl>how,equ>but_not,obj>uw,bas<thing),signal(icl>communication>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Provides, for example, the ability to inform a train that the signal ahead has cleared. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(ability(icl>quality>thing,ant>inability).@def,for_example(icl>how).@parenth)\n",
+    "cnt(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present,ability(icl>quality>thing,ant>inability).@def)\n",
+    "obj(have(icl>be,obj>thing,aoj>thing).@present.@complete,ability(icl>quality>thing,ant>inability).@def)\n",
+    "obj:01(inform(icl>communicate>do,equ>notify,cob>thing,agt>thing,obj>person).@entry,train(icl>public_transport>thing).@indef)\n",
+    "aoj(have(icl>be,obj>thing,aoj>thing).@present.@complete,signal(icl>communication>thing).@def)\n",
+    "mod(signal(icl>communication>thing).@def,ahead(icl>how,ant>back))\n",
+    "obj(ability(icl>quality>thing,ant>inability).@def,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A is said to be in rear of B if a train would pass A before B in the direction of travel.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A is said to be in rear of B if a train would pass A before B in the direction of travel. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:01(be in.@entry,rear(icl>formation>thing,ant>head).@indef)\n",
+    "obj:01(rear(icl>formation>thing,ant>head).@indef,b:01)\n",
+    "agt:02(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@probable,train(icl>public_transport>thing).@indef)\n",
+    "plc:02(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present.@probable,a)\n",
+    "plc:02(a,before(icl>how,obj>thing,plc<uw))\n",
+    "obj:02(before(icl>how,obj>thing,plc<uw),b:02)\n",
+    "plc:02(b:02,direction(icl>path>thing).@def)\n",
+    "obj:02(direction(icl>path>thing).@def,travel(icl>motion>thing))\n",
+    "rec(say(icl>communicate>do,equ>tell,agt>person,obj>uw,cao>thing,rec>volitional_thing).@entry.@present,:01)\n",
+    "con(say(icl>communicate>do,equ>tell,agt>person,obj>uw,cao>thing,rec>volitional_thing).@entry.@present,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Trackside safety system for trains running in stations.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Trackside safety system for trains running in stations. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(safety(icl>condition>thing,ant>danger),trackside)\n",
+    "mod(system(icl>group>thing).@entry,safety(icl>condition>thing,ant>danger))\n",
+    "plt(system(icl>group>thing).@entry,train(icl>public_transport>thing).@pl)\n",
+    "mod(train(icl>public_transport>thing).@pl,run in.@progress)\n",
+    "obj(run in.@progress,station(icl>facility>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track-to-train or train-to-track transmission which can only take place when the train passes the information point (balise or short/medium loop or radio area)\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track-to-train or train-to-track transmission which can only take place when the train passes the information point (balise or short/medium loop or radio area). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or(train(icl>public_transport>thing):01,track(icl>line>thing,equ>path))\n",
+    "pur(track(icl>line>thing,equ>path),train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "aoj(point(icl>indicate>be,obj>thing,aoj>thing).@entry.@present,train(icl>public_transport>thing):01)\n",
+    "pur(train(icl>public_transport>thing):01,track(icl>mark>do,agt>thing,obj>thing))\n",
+    "obj(track(icl>mark>do,agt>thing,obj>thing),transmission(icl>sending>thing))\n",
+    "aoj(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@present.@ability,transmission(icl>sending>thing))\n",
+    "man(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@present.@ability,only(icl>how,com>result))\n",
+    "obj(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@present.@ability,place(icl>space>thing,equ>seat))\n",
+    "agt:02(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present,train(icl>public_transport>thing):02.@def)\n",
+    "plc:02(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@entry.@present,information(icl>message>thing).@def)\n",
+    "or:03(loop(icl>fastener>thing,equ>cringle).@entry,balise.@entry)\n",
+    "or:01(medium(icl>adj,equ>average),short(icl>adj,ant>long,com>length))\n",
+    "mod(balise.@entry,medium(icl>adj,equ>average))\n",
+    "or(area(icl>extent>abstract_thing,obj>thing),loop(icl>fastener>thing,equ>cringle).@entry)\n",
+    "mod:01(area(icl>extent>abstract_thing,obj>thing),radio(icl>media>abstract_thing))\n",
+    "mod:03(loop(icl>fastener>thing,equ>cringle).@entry,:01.@parenthesis)\n",
+    "tim(take(icl>perceive>be,obj>thing,aoj>person,man>uw).@present.@ability,:02)\n",
+    "shd(point(icl>indicate>be,obj>thing,aoj>thing).@entry.@present,:03.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Where ETCS takes control from the driver by cutting traction power (as an option) or  applying the full service brake and cutting traction power or applying the emergency brake and cutting traction power.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Where ETCS takes control from the driver by cutting traction power (as an option) or  applying the full service brake and cutting traction power or applying the emergency brake and cutting traction power. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(take(icl>remove>do,equ>take_away,plt>uw,plf>uw,agt>thing,obj>thing).@entry.@present,where(icl>how,plc<uw))\n",
+    "agt(take(icl>remove>do,equ>take_away,plt>uw,plf>uw,agt>thing,obj>thing).@entry.@present,etcs)\n",
+    "obj(take(icl>remove>do,equ>take_away,plt>uw,plf>uw,agt>thing,obj>thing).@entry.@present,control(icl>power>thing))\n",
+    "plf(take(icl>remove>do,equ>take_away,plt>uw,plf>uw,agt>thing,obj>thing).@entry.@present,from(icl>how,equ>according_to,obj>thing))\n",
+    "obj(from(icl>how,equ>according_to,obj>thing),driver(icl>operator>thing,ant>nondriver).@def)\n",
+    "mod:02(power(icl>quality>thing,ant>powerlessness):01,traction(icl>pull>thing):01)\n",
+    "obj:02(cut(icl>divide>do,agt>volitional_thing,obj>concrete_thing,gol>concrete_thing,ins>functional_thing):01.@entry,power(icl>quality>thing,ant>powerlessness):01)\n",
+    "obj:01(as(icl>how,com>degree,obj>uw,man<uw).@entry,option(icl>action>thing,equ>choice).@indef)\n",
+    "mod:03(service(icl>work>action,agt>thing,obj>thing).@def,full(icl>adj,ant>empty))\n",
+    "mod:03(brake(icl>restraint>thing):01,service(icl>work>action,agt>thing,obj>thing).@def)\n",
+    "obj:03(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing):01,brake(icl>restraint>thing):01)\n",
+    "mod:04(power(icl>quality>thing,ant>powerlessness):02,traction(icl>pull>thing):02)\n",
+    "obj:04(cut(icl>divide>do,agt>volitional_thing,obj>concrete_thing,gol>concrete_thing,ins>functional_thing):02,power(icl>quality>thing,ant>powerlessness):02)\n",
+    "mod:05(brake(icl>restraint>thing):02,emergency(icl>crisis>thing).@def)\n",
+    "obj:05(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing):02,brake(icl>restraint>thing):02)\n",
+    "mod:06(power(icl>quality>thing,ant>powerlessness):03,traction(icl>pull>thing):03)\n",
+    "obj:06(cut(icl>divide>do,agt>volitional_thing,obj>concrete_thing,gol>concrete_thing,ins>functional_thing):03,power(icl>quality>thing,ant>powerlessness):03)\n",
+    "man:02(power(icl>quality>thing,ant>powerlessness):01,:01.@parenthesis)\n",
+    "or(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing):01,:02)\n",
+    "and(cut(icl>divide>do,agt>volitional_thing,obj>concrete_thing,gol>concrete_thing,ins>functional_thing):02,:03)\n",
+    "or(apply(icl>use>do,cob>uw,agt>volitional_thing,obj>thing):02,:04)\n",
+    "and(cut(icl>divide>do,agt>volitional_thing,obj>concrete_thing,gol>concrete_thing,ins>functional_thing):03,:05)\n",
+    "met(take(icl>remove>do,equ>take_away,plt>uw,plf>uw,agt>thing,obj>thing).@entry.@present,:06)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Universal Time Corrected + local offset\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Universal Time Corrected + local offset. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(time(icl>abstract_thing,equ>period).@maiuscul,universal(icl>adj,equ>cosmopolitan))\n",
+    "agt(correct(icl>change_by_reversal>do,agt>volitional_thing,obj>thing).@entry.@past.@maiuscul,time(icl>abstract_thing,equ>period).@maiuscul)\n",
+    "mod(offset(icl>plant_organ>thing,equ>stolon),+)\n",
+    "mod(offset(icl>plant_organ>thing,equ>stolon),local(icl>adj,ant>national))\n",
+    "obj(correct(icl>change_by_reversal>do,agt>volitional_thing,obj>thing).@entry.@past.@maiuscul,offset(icl>plant_organ>thing,equ>stolon))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A fixed signal intended for train movements, capable of showing a \"danger\" aspect and one or more \"proceed\" aspects. In some cases main signals at \"danger\" are valid also for shunt movement.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A fixed signal intended for train movements, capable of showing a \"danger\" aspect and one or more \"proceed\" aspects. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,signal(icl>communication>thing).@indef)\n",
+    "aoj(intend(icl>will>be,obj>uw,aoj>person).@entry.@past,signal(icl>communication>thing).@indef)\n",
+    "or(:02,intend(icl>will>be,obj>uw,aoj>person).@entry.@past)\n",
+    "mod(movement(icl>happening>thing).@pl,train(icl>public_transport>thing))\n",
+    "pur(intend(icl>will>be,obj>uw,aoj>person).@entry.@past,movement(icl>happening>thing).@pl)\n",
+    "mod(movement(icl>happening>thing).@pl,capable(icl>adj))\n",
+    "obj(capable(icl>adj),show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing))\n",
+    "mod(:03.@_hn-scope,danger(icl>condition>thing,ant>safety).@double_quote)\n",
+    "and:03(one(icl>digit>thing).@entry,aspect(icl>feature>thing):01.@entry.@indef)\n",
+    "man:02(proceed(icl>talk>do,equ>continue,plf>thing,agt>person,obj>action).@entry.@present.@double_quote,more(icl>how))\n",
+    "agt:02(proceed(icl>talk>do,equ>continue,plf>thing,agt>person,obj>action).@entry.@present.@double_quote,aspect(icl>feature>thing):02.@pl)\n",
+    "obj(show(icl>demonstrate>do,agt>thing,obj>thing,rec>thing),:03.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In some cases main signals at \"danger\" are valid also for shunt movement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(case(icl>happening>thing).@pl,some(icl>adj))\n",
+    "scn(valid(icl>adj,ant>invalid).@entry.@present,case(icl>happening>thing).@pl)\n",
+    "mod(signal(icl>communication>thing).@pl,main(icl>adj,equ>chief))\n",
+    "aoj(valid(icl>adj,ant>invalid).@entry.@present,signal(icl>communication>thing).@pl)\n",
+    "tim(signal(icl>communication>thing).@pl,danger(icl>condition>thing,ant>safety).@double_quote)\n",
+    "man(movement(icl>happening>thing),also(icl>how,equ>besides))\n",
+    "mod(movement(icl>happening>thing),shunt(icl>passage>thing))\n",
+    "obj(valid(icl>adj,ant>invalid).@entry.@present,movement(icl>happening>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Permission for a train to run to a specific location within the constraints of the infrastructure.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Permission for a train to run to a specific location within the constraints of the infrastructure. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plt(permission(icl>approval>thing).@entry,train(icl>public_transport>thing).@indef)\n",
+    "obj(permission(icl>approval>thing).@entry,run(icl>go>do,plt>uw,plf>uw,agt>thing))\n",
+    "mod(location(icl>object>thing).@indef,specific(icl>adj,equ>particular,ant>general))\n",
+    "plt(run(icl>go>do,plt>uw,plf>uw,agt>thing),location(icl>object>thing).@indef)\n",
+    "obj(location(icl>object>thing).@indef,within(icl>how,com>limit,obj>thing,scn<abstract_thing))\n",
+    "obj(within(icl>how,com>limit,obj>thing,scn<abstract_thing),constraint(icl>restriction>thing).@def.@pl)\n",
+    "obj(constraint(icl>restriction>thing).@def.@pl,infrastructure(icl>structure>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A block in which the extremities of the block sections are continually adjusted according to the position of the occupying train.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A block in which the extremities of the block sections are continually adjusted according to the position of the occupying train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc:01(adjust(icl>change>do,equ>correct,cob>thing,agt>volitional_thing,obj>thing).@pl.@present,block(icl>artifact>thing):01.@entry.@indef)\n",
+    "obj:01(adjust(icl>change>do,equ>correct,cob>thing,agt>volitional_thing,obj>thing).@pl.@present,extremity(icl>region>thing).@def.@pl.@topic)\n",
+    "mod:01(section(icl>writing>thing).@def.@pl,block(icl>artifact>thing):02)\n",
+    "obj:01(extremity(icl>region>thing).@def.@pl.@topic,section(icl>writing>thing).@def.@pl)\n",
+    "man:01(adjust(icl>change>do,equ>correct,cob>thing,agt>volitional_thing,obj>thing).@pl.@present,continually(icl>how,com>continual))\n",
+    "src:01(adjust(icl>change>do,equ>correct,cob>thing,agt>volitional_thing,obj>thing).@pl.@present,according_to(icl>how,src>uw,obj>uw))\n",
+    "obj:01(according_to(icl>how,src>uw,obj>uw),position(icl>place,aoj>thing,plc>thing).@def)\n",
+    "aoj:01(position(icl>place,aoj>thing,plc>thing).@def,train(icl>public_transport>thing).@def)\n",
+    "aoj:01(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@progress,train(icl>public_transport>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Two or more traction units in service, mechanically pneumatically and electrically coupled, which are operated by one driver.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Two or more traction units in service, mechanically pneumatically and electrically coupled, which are operated by one driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or:01(more(icl>how),two(icl>digit>thing))\n",
+    "qua:01(unit(icl>measure>abstract_thing,aoj>uw).@pl,more(icl>how))\n",
+    "mod:01(unit(icl>measure>abstract_thing,aoj>uw).@pl,traction(icl>pull>thing))\n",
+    "agt:01(couple(icl>join>do,equ>match,cob>thing,agt>thing,obj>thing).@entry.@past,unit(icl>measure>abstract_thing,aoj>uw).@pl)\n",
+    "plc:01(unit(icl>measure>abstract_thing,aoj>uw).@pl,service(icl>work>action,agt>thing,obj>thing))\n",
+    "man(:02.@_hn-scope,mechanically(icl>how,com>mechanical))\n",
+    "and:02(electrically(icl>how,com>electric).@entry,pneumatically(icl>how,com>pneumatic).@entry)\n",
+    "qua(driver(icl>operator>thing,ant>nondriver),one(icl>digit>thing))\n",
+    "agt(operate(icl>manage>do,agt>volitional_thing,obj>thing).@entry.@pl.@present,driver(icl>operator>thing,ant>nondriver))\n",
+    "obj(operate(icl>manage>do,agt>volitional_thing,obj>thing).@entry.@pl.@present,:01)\n",
+    "man(couple(icl>join>do,equ>match,cob>thing,agt>thing,obj>thing).@entry.@past,:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Values transmitted to a train when entering another administration related to the rules and regulations of this administration.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Values transmitted to a train when entering another administration related to the rules and regulations of this administration. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@state,value(icl>property,obj>thing).@pl)\n",
+    "agt(relate(icl>think>do,equ>associate,agt>thing,obj>thing).@entry.@past,value(icl>property,obj>thing).@pl)\n",
+    "ben(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing).@state,train(icl>public_transport>thing).@indef)\n",
+    "mod:01(administration(icl>abstract_thing,agt>thing,obj>thing):01,another(icl>adj,equ>another))\n",
+    "obj:01(enter(icl>do,equ>join,agt>volitional_thing,obj>thing).@entry,administration(icl>abstract_thing,agt>thing,obj>thing):01)\n",
+    "and(regulation(icl>rule>thing).@pl,rule(icl>practice>thing,equ>convention).@def.@pl)\n",
+    "obj(relate(icl>think>do,equ>associate,agt>thing,obj>thing).@entry.@past,regulation(icl>rule>thing).@pl)\n",
+    "mod(administration(icl>abstract_thing,agt>thing,obj>thing):02,this(icl>determiner>adj,mod<concrete_thing))\n",
+    "obj(regulation(icl>rule>thing).@pl,administration(icl>abstract_thing,agt>thing,obj>thing):02)\n",
+    "tim(train(icl>public_transport>thing).@indef,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "No trackside ETCS equipment installed or installed only for Partial Supervision\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "No trackside ETCS equipment installed or installed only for Partial Supervision. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(trackside,no(icl>quantity,qua<thing))\n",
+    "mod(etcs,trackside)\n",
+    "mod(equipment(icl>instrumentality>thing).@entry,etcs)\n",
+    "obj(install(icl>set_up>do,plt>thing,agt>volitional_thing,obj>concrete_thing):01.@state,equipment(icl>instrumentality>thing).@entry)\n",
+    "or(install(icl>set_up>do,plt>thing,agt>volitional_thing,obj>concrete_thing):02,install(icl>set_up>do,plt>thing,agt>volitional_thing,obj>concrete_thing):01.@state)\n",
+    "mod(install(icl>set_up>do,plt>thing,agt>volitional_thing,obj>concrete_thing):01.@state,only(icl>how,equ>merely))\n",
+    "mod(install(icl>set_up>do,plt>thing,agt>volitional_thing,obj>concrete_thing):02,only(icl>how,equ>merely))\n",
+    "mod(supervision(icl>management>thing).@maiuscul,partial(icl>adj).@maiuscul)\n",
+    "pur(install(icl>set_up>do,plt>thing,agt>volitional_thing,obj>concrete_thing):02,supervision(icl>management>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Used for speed measurement and distance measurement.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Used for speed measurement and distance measurement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(:01.@_hn-scope,speed(icl>rate>thing))\n",
+    "and:01(distance(icl>spacing>thing).@entry,measurement(icl>activity>thing):01.@entry)\n",
+    "pur(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry,measurement(icl>activity>thing):02)\n",
+    "mod(measurement(icl>activity>thing):02,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Part of an entrance route located after the end of the route and locked as the route. The overlap must not be released until the train has stopped.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Part of an entrance route located after the end of the route and locked as the route. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(locate(icl>settle>do,agt>person,plc>thing).@entry.@past,part(icl>region>abstract_thing,pof>area))\n",
+    "mod(route(icl>line>thing,equ>path):01.@indef,entrance(icl>access>thing))\n",
+    "pof(part(icl>region>abstract_thing,pof>area),route(icl>line>thing,equ>path):01.@indef)\n",
+    "and(lock(icl>be,obj>thing,aoj>concrete_thing).@past,locate(icl>settle>do,agt>person,plc>thing).@entry.@past)\n",
+    "tim(locate(icl>settle>do,agt>person,plc>thing).@entry.@past,after(icl>how,tim<uw,obj>uw))\n",
+    "tim(lock(icl>be,obj>thing,aoj>concrete_thing).@past,after(icl>how,tim<uw,obj>uw))\n",
+    "obj(after(icl>how,tim<uw,obj>uw),end(icl>moment>time,ant>beginning).@def)\n",
+    "obj(end(icl>moment>time,ant>beginning).@def,route(icl>line>thing,equ>path):02.@def)\n",
+    "man(lock(icl>be,obj>thing,aoj>concrete_thing).@past,as(icl>how,com>degree,obj>uw,man<uw))\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw),route(icl>line>thing,equ>path):03.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The overlap must not be released until the train has stopped. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry.@not.@present.@obligation-strong,overlap(icl>concurrence>thing).@def.@topic)\n",
+    "agt:01(stop(icl>do,ant>move,agt>concrete_thing,plc>uw).@entry.@present.@complete,train(icl>public_transport>thing).@def)\n",
+    "tmt(release(icl>do,ant>hold,plt>thing,plf>thing,agt>thing,obj>concrete_thing).@entry.@not.@present.@obligation-strong,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Device for transmitting power from overhead wire to the train.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Device for transmitting power from overhead wire to the train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(device(icl>instrumentality>thing).@entry,transmit(icl>pass>do,agt>thing,obj>thing,ben>thing))\n",
+    "obj(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),power(icl>quality>thing,ant>powerlessness))\n",
+    "mod(wire(icl>ligament>thing),overhead(icl>adj,ant>surface))\n",
+    "plf(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),wire(icl>ligament>thing))\n",
+    "ben(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),train(icl>public_transport>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A signal aspect or a signal identification, which enables a main signal to be passed at \"danger\" under special conditions, without specific permission from signalman.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A signal aspect or a signal identification, which enables a main signal to be passed at \"danger\" under special conditions, without specific permission from signalman. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(aspect(icl>feature>thing).@entry.@indef,signal(icl>adj):01)\n",
+    "or(identification(icl>determination>thing,equ>designation).@indef,aspect(icl>feature>thing).@entry.@indef)\n",
+    "mod(aspect(icl>feature>thing).@entry.@indef,signal(icl>adj):02)\n",
+    "mod(identification(icl>determination>thing,equ>designation).@indef,signal(icl>adj):02)\n",
+    "agt(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@present,identification(icl>determination>thing,equ>designation).@indef)\n",
+    "mod:01(signal(icl>communication>thing).@entry.@indef,main(icl>adj,equ>chief))\n",
+    "obj:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),signal(icl>communication>thing).@entry.@indef)\n",
+    "tim:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),danger(icl>condition>thing,ant>safety).@double_quote)\n",
+    "plc:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),under(icl>how,equ>below,obj>thing,plc<uw))\n",
+    "mod:01(condition(icl>state>abstract_thing,aoj>thing).@pl,special(icl>adj,equ>particular))\n",
+    "obj:01(under(icl>how,equ>below,obj>thing,plc<uw),condition(icl>state>abstract_thing,aoj>thing).@pl)\n",
+    "man:01(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing),without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "mod:01(permission(icl>approval>thing),specific(icl>adj,equ>particular,ant>general))\n",
+    "obj:01(without(icl>how,ant>with,com>physical,obj>thing),permission(icl>approval>thing))\n",
+    "agt:01(permission(icl>approval>thing),signalman(icl>trainman>thing))\n",
+    "obj(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing).@present,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The speed limit at which a train is allowed to proceed without ETCS warning and/or intervention.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The speed limit at which a train is allowed to proceed without ETCS warning and/or intervention. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(limit(icl>extent>thing).@entry.@def,speed(icl>rate>thing))\n",
+    "plc(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@present,limit(icl>extent>thing).@entry.@def)\n",
+    "ben(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@present,train(icl>public_transport>thing).@indef.@topic)\n",
+    "obj(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@present,proceed(icl>talk>do,equ>continue,plf>thing,agt>person,obj>action))\n",
+    "man(proceed(icl>talk>do,equ>continue,plf>thing,agt>person,obj>action),without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "mod(:01.@_hn-scope,etcs)\n",
+    "and:01(and or.@entry,warning(icl>informing>thing).@entry)\n",
+    "obj:01(and or.@entry,intervention(icl>engagement>thing))\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing),:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A train movement, in which the driver is not situated in the leading vehicle. When propelling the operative cab is next to the train being propelled and the master switch is in Forward. A train set can not propel itself (see reversing) but is able to propel another trainset.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A train movement, in which the driver is not situated in the leading vehicle. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(movement(icl>happening>thing).@indef,train(icl>public_transport>thing))\n",
+    "cnt(driver(icl>operator>thing,ant>nondriver).@def.@topic,movement(icl>happening>thing).@indef)\n",
+    "plc(movement(icl>happening>thing).@indef,which)\n",
+    "obj(situate(icl>set>do,plt>thing,agt>person,obj>thing).@entry.@not.@present,driver(icl>operator>thing,ant>nondriver).@def.@topic)\n",
+    "plc(situate(icl>set>do,plt>thing,agt>person,obj>thing).@entry.@not.@present,vehicle(icl>functional_thing,pur>thing).@def)\n",
+    "agt(lead(icl>induce>do,agt>thing,obj>volitional_thing,gol>uw).@progress,vehicle(icl>functional_thing,pur>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When propelling the operative cab is next to the train being propelled and the master switch is in Forward. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "con(next(icl>adj,equ>adjacent).@entry.@present,when(icl>how,com>condition,obj>uw,con<uw))\n",
+    "obj(when(icl>how,com>condition,obj>uw,con<uw),propelling(icl>adj,equ>propellant))\n",
+    "mod(cab(icl>compartment>thing).@def,operative(icl>adj,ant>inoperative))\n",
+    "aoj(next(icl>adj,equ>adjacent).@entry.@present,cab(icl>compartment>thing).@def)\n",
+    "and(:01,next(icl>adj,equ>adjacent).@entry.@present)\n",
+    "obj(next(icl>adj,equ>adjacent).@entry.@present,train(icl>public_transport>thing).@def)\n",
+    "man(next(icl>adj,equ>adjacent).@entry.@present,propel(icl>move>do,agt>thing,obj>thing))\n",
+    "mod:01(switch(icl>control>thing).@def,master)\n",
+    "aoj:01(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,switch(icl>control>thing).@def)\n",
+    "plc:01(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,forward(icl>position>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A train set can not propel itself (see reversing) but is able to propel another trainset. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:03(set(icl>displace>do,agt>thing,obj>thing,plc>uw).@state,train(icl>public_transport>thing).@indef)\n",
+    "agt:03(propel(icl>move>do,agt>thing,obj>thing):01.@entry.@present.@ability-not,train(icl>public_transport>thing).@indef)\n",
+    "obj:03(but(icl>how,equ>however,obj>uw,and<uw),propel(icl>move>do,agt>thing,obj>thing):01.@entry.@present.@ability-not)\n",
+    "obj:03(propel(icl>move>do,agt>thing,obj>thing):01.@entry.@present.@ability-not,it(icl>concrete_thing))\n",
+    "aoj:03(propel(icl>move>do,agt>thing,obj>thing):02.@present.@ability,but(icl>how,equ>however,obj>uw,and<uw))\n",
+    "mod:03(trainset,another(icl>adj,equ>another))\n",
+    "obj:03(propel(icl>move>do,agt>thing,obj>thing):02.@present.@ability,trainset)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Administrative data base outside the scope of ETCS. From this data base ETCS may provide information for train supervision as well as for advisory purposes.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Administrative data base outside the scope of ETCS. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(base(icl>abstract_thing,equ>basis,obj>uw).@entry,administrative(icl>adj,com>administration))\n",
+    "mod(base(icl>abstract_thing,equ>basis,obj>uw).@entry,data(icl>collection>thing))\n",
+    "plc(base(icl>abstract_thing,equ>basis,obj>uw).@entry,outside(icl>how,ant>inside,obj>thing,plc<uw))\n",
+    "obj(outside(icl>how,ant>inside,obj>thing,plc<uw),scope(icl>extent>thing).@def)\n",
+    "obj(scope(icl>extent>thing).@def,etcs)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "From this data base ETCS may provide information for train supervision as well as for advisory purposes. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(suppose(icl>modal>be,obj>uw,aoj>thing).@entry,from(icl>how,com>origin,obj>thing))\n",
+    "mod(base(icl>abstract_thing,equ>basis,obj>uw),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "mod(base(icl>abstract_thing,equ>basis,obj>uw),data(icl>collection>thing))\n",
+    "obj(from(icl>how,com>origin,obj>thing),base(icl>abstract_thing,equ>basis,obj>uw))\n",
+    "aoj(suppose(icl>modal>be,obj>uw,aoj>thing).@entry,etcs)\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing),etcs)\n",
+    "obj(suppose(icl>modal>be,obj>uw,aoj>thing).@entry,provide(icl>equip>do,cob>thing,obj>thing))\n",
+    "obj(as_well_as(icl>how,obj>uw,and<uw),provide(icl>equip>do,cob>thing,obj>thing))\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing),information(icl>message>thing))\n",
+    "mod(supervision(icl>management>thing),train(icl>public_transport>thing))\n",
+    "pur(provide(icl>equip>do,cob>thing,obj>thing),supervision(icl>management>thing))\n",
+    "mod(purpose(icl>abstract_thing,equ>aim,obj>uw,aoj>action).@pl,advisory(icl>adj))\n",
+    "pur(as_well_as(icl>how,obj>uw,and<uw),purpose(icl>abstract_thing,equ>aim,obj>uw,aoj>action).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Radio Block Centre. A centralized safety unit to establish and control train separation. Receives location information from all trains and generates movement authorities to all trains. May provide an interface to interlocking systems for (partial) control of interlocking and indications from interlocking. Provides a train control possibility. The ETCS data radio channel used is a safe data transmission channel not intended for spoken communication.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Radio Block Centre. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(block,radio(icl>adj,equ>radioactive))\n",
+    "mod(center(icl>place,pof>concrete_thing).@entry.@maiuscul,block)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A centralized safety unit to establish and control train separation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@entry.@indef,safety(icl>condition>thing,ant>danger))\n",
+    "obj(centralize(icl>change>occur,obj>thing).@state,unit(icl>measure>abstract_thing,aoj>uw).@entry.@indef)\n",
+    "and(:01,establish(icl>found>do,agt>volitional_thing,obj>thing,scn>thing))\n",
+    "mod:01(separation(icl>change_of_integrity>thing),train(icl>public_transport>thing))\n",
+    "obj:01(control(icl>do,equ>command,agt>volitional_thing,obj>volitional_thing).@entry,separation(icl>change_of_integrity>thing))\n",
+    "pur(unit(icl>measure>abstract_thing,aoj>uw).@entry.@indef,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Receives location information from all trains and generates movement authorities to all trains. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(information(icl>message>thing),location(icl>object>thing))\n",
+    "agt(receive(icl>acquire>do,src>thing,obj>thing).@entry.@present,information(icl>message>thing))\n",
+    "agt(generate(icl>do,equ>give,agt>thing,obj>thing).@present,information(icl>message>thing))\n",
+    "qua(train(icl>public_transport>thing):01.@pl,all(icl>quantity,ant>some,per>thing):01)\n",
+    "plf(receive(icl>acquire>do,src>thing,obj>thing).@entry.@present,train(icl>public_transport>thing):01.@pl)\n",
+    "plf(generate(icl>do,equ>give,agt>thing,obj>thing).@present,train(icl>public_transport>thing):01.@pl)\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@pl,movement(icl>happening>thing))\n",
+    "obj(generate(icl>do,equ>give,agt>thing,obj>thing).@present,authority(icl>abstract_thing,obj>uw).@pl)\n",
+    "qua(train(icl>public_transport>thing):02.@pl,all(icl>quantity,ant>some,per>thing):02)\n",
+    "plt(receive(icl>acquire>do,src>thing,obj>thing).@entry.@present,train(icl>public_transport>thing):02.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "May provide an interface to interlocking systems for (partial) control of interlocking and indications from interlocking. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@suppose,interface(icl>surface>thing).@indef)\n",
+    "obj(interface(icl>surface>thing).@indef,interlock(icl>organize>do,cob>thing,agt>volitional_thing,obj>thing):01)\n",
+    "agt(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present.@suppose,system(icl>group>thing).@pl)\n",
+    "mod(system(icl>group>thing).@pl,partial(icl>adj).@parenthesis)\n",
+    "ben(system(icl>group>thing).@pl,control(icl>power>thing))\n",
+    "and(indication(icl>communication>thing).@pl,interlock(icl>organize>do,cob>thing,agt>volitional_thing,obj>thing):02)\n",
+    "obj(control(icl>power>thing),indication(icl>communication>thing).@pl)\n",
+    "rsn(indication(icl>communication>thing).@pl,interlock(icl>organize>do,cob>thing,agt>volitional_thing,obj>thing):03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Provides a train control possibility. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(control(icl>power>thing),train(icl>public_transport>thing))\n",
+    "mod(possibility(icl>perspective>abstract_thing,obj>uw).@indef,control(icl>power>thing))\n",
+    "obj(provide(icl>equip>do,cob>thing,obj>thing).@entry.@present,possibility(icl>perspective>abstract_thing,obj>uw).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS data radio channel used is a safe data transmission channel not intended for spoken communication. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(data(icl>collection>thing):01,etcs)\n",
+    "mod:01(radio(icl>media>abstract_thing),data(icl>collection>thing):01)\n",
+    "mod:01(channel(icl>transmission>thing):01.@def,radio(icl>media>abstract_thing))\n",
+    "obj:01(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,channel(icl>transmission>thing):01.@def)\n",
+    "aoj:01(transmission(icl>sending>thing).@entry.@indef.@present,channel(icl>transmission>thing):01.@def)\n",
+    "mod:01(data(icl>collection>thing):02,safe(icl>adj,ant>dangerous))\n",
+    "mod:01(transmission(icl>sending>thing).@entry.@indef.@present,data(icl>collection>thing):02)\n",
+    "mod:01(intend(icl>will>be,obj>uw,aoj>person).@past.@not,transmission(icl>sending>thing).@entry.@indef.@present)\n",
+    "aoj:01(intend(icl>will>be,obj>uw,aoj>person).@past.@not,channel(icl>transmission>thing):02)\n",
+    "mod:01(communication(icl>action,agt>thing,ptn>thing),spoken(icl>adj,equ>oral,ant>written).@state)\n",
+    "pur:01(intend(icl>will>be,obj>uw,aoj>person).@past.@not,communication(icl>action,agt>thing,ptn>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Information point used for train location updating. Used to correct error of odometry.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Information point used for train location updating. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(point(icl>component>thing).@entry,information(icl>message>thing))\n",
+    "obj:01(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,point(icl>component>thing).@entry)\n",
+    "mod:01(location(icl>object>thing),train(icl>public_transport>thing))\n",
+    "agt:01(update(icl>inform>do,agt>thing,obj>thing),location(icl>object>thing))\n",
+    "pur:01(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@state,update(icl>inform>do,agt>thing,obj>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Used to correct error of odometry. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj:01(correct(icl>change_by_reversal>do,agt>volitional_thing,obj>thing).@entry,error(icl>nonaccomplishment>thing,equ>mistake))\n",
+    "obj:01(error(icl>nonaccomplishment>thing,equ>mistake),odometry)\n",
+    "pur(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A train following another in less than absolute braking distance of the following train.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A train following another in less than absolute braking distance of the following train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(follow(icl>move>do,equ>go_after,agt>volitional_thing,obj>volitional_thing).@progress,train(icl>public_transport>thing):01.@entry.@indef)\n",
+    "obj(follow(icl>move>do,equ>go_after,agt>volitional_thing,obj>volitional_thing).@progress,another(icl>adj,equ>another))\n",
+    "man(brake(icl>stop>occur,obj>thing).@progress,less(icl>how))\n",
+    "bas(less(icl>how),absolute(icl>adj,ant>relative))\n",
+    "scn(another(icl>adj,equ>another),distance(icl>spacing>thing))\n",
+    "obj(brake(icl>stop>occur,obj>thing).@progress,distance(icl>spacing>thing))\n",
+    "mod(train(icl>public_transport>thing):02.@def,following(icl>adj,ant>leading))\n",
+    "mod(distance(icl>spacing>thing),train(icl>public_transport>thing):02.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A speed value calculated by the ETCS trainborne equipment to allow a train to approach the end of its movement authority in a safe way. Needed for intermittent transmission to enable the train to approach a signal that has cleared in order to reach the information point at the signal.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A speed value calculated by the ETCS trainborne equipment to allow a train to approach the end of its movement authority in a safe way. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(value(icl>appraise>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@imperative,speed(icl>rate>thing).@indef)\n",
+    "mod:01(trainborne,etcs.@def)\n",
+    "mod:01(equipment(icl>instrumentality>thing),trainborne)\n",
+    "agt:01(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry,equipment(icl>instrumentality>thing))\n",
+    "ben:02(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry,train(icl>public_transport>thing).@indef)\n",
+    "obj:03(approach(icl>border_on>be,obj>abstract_thing,aoj>abstract_thing).@entry,end(icl>moment>time,ant>beginning).@def)\n",
+    "pos:03(authority(icl>abstract_thing,obj>uw),it(icl>living_thing))\n",
+    "mod:03(authority(icl>abstract_thing,obj>uw),movement(icl>happening>thing))\n",
+    "agt:03(end(icl>moment>time,ant>beginning).@def,authority(icl>abstract_thing,obj>uw))\n",
+    "mod:02(way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef,safe(icl>adj,ant>dangerous))\n",
+    "plc:02(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry,way(icl>property>abstract_thing,equ>manner,obj>action,pos>volitional_thing).@indef)\n",
+    "man(value(icl>appraise>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@imperative,:01)\n",
+    "pur:01(calculate(icl>compute>do,com>mathematics,agt>volitional_thing,obj>thing,ins>mechanism).@entry,:02)\n",
+    "obj:02(allow(icl>do,equ>permit,agt>volitional_thing,obj>uw,ben>volitional_thing).@entry,:03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Needed for intermittent transmission to enable the train to approach a signal that has cleared in order to reach the information point at the signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(transmission(icl>sending>thing).@entry,intermittent(icl>adj))\n",
+    "obj(need(icl>require>be,obj>uw,aoj>thing).@past.@complete,transmission(icl>sending>thing).@entry)\n",
+    "pur(transmission(icl>sending>thing).@entry,enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing))\n",
+    "obj(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing),train(icl>public_transport>thing).@def)\n",
+    "gol(enable(icl>do,agt>thing,obj>thing,gol>uw,met>thing),approach(icl>border_on>be,obj>abstract_thing,aoj>abstract_thing))\n",
+    "obj(approach(icl>border_on>be,obj>abstract_thing,aoj>abstract_thing),signal(icl>communication>thing):01.@indef)\n",
+    "obj(clear(icl>brighten>occur,cob>concrete_thing,obj>space>thing).@present.@complete,signal(icl>communication>thing):01.@indef)\n",
+    "pur(clear(icl>brighten>occur,cob>concrete_thing,obj>space>thing).@present.@complete,in_order_to(icl>how,obj>uw,pur<uw))\n",
+    "obj(in_order_to(icl>how,obj>uw,pur<uw),reach(icl>transfer>do,obj>thing,gol>uw))\n",
+    "obj(reach(icl>transfer>do,obj>thing,gol>uw),information(icl>message>thing).@def)\n",
+    "gol(reach(icl>transfer>do,obj>thing,gol>uw),point(icl>component>thing))\n",
+    "plc(point(icl>component>thing),signal(icl>communication>thing):02.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A train movement, in which the driver is not situated in the leading vehicle. When reversing the operative cab of a locomotive is not next to the train being reversed. The operative cab of a train set will be an integral part of that train set. In both cases the master switch is in Reverse.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A train movement, in which the driver is not situated in the leading vehicle. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(movement(icl>happening>thing).@indef,train(icl>public_transport>thing))\n",
+    "cnt(driver(icl>operator>thing,ant>nondriver).@def.@topic,movement(icl>happening>thing).@indef)\n",
+    "plc(movement(icl>happening>thing).@indef,which)\n",
+    "obj(situate(icl>set>do,plt>thing,agt>person,obj>thing).@entry.@not.@present,driver(icl>operator>thing,ant>nondriver).@def.@topic)\n",
+    "plc(situate(icl>set>do,plt>thing,agt>person,obj>thing).@entry.@not.@present,vehicle(icl>functional_thing,pur>thing).@def)\n",
+    "agt(lead(icl>induce>do,agt>thing,obj>volitional_thing,gol>uw).@progress,vehicle(icl>functional_thing,pur>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When reversing the operative cab of a locomotive is not next to the train being reversed. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(when(icl>how,tim<uw,obj>uw).@entry,reverse(icl>change>do,agt>thing,obj>thing):01)\n",
+    "aoj(next(icl>adj,equ>adjacent).@not.@present,reverse(icl>change>do,agt>thing,obj>thing):01)\n",
+    "mod(cab(icl>compartment>thing).@def,operative(icl>adj,ant>inoperative))\n",
+    "obj(reverse(icl>change>do,agt>thing,obj>thing):01,cab(icl>compartment>thing).@def)\n",
+    "mod(cab(icl>compartment>thing).@def,locomotive(icl>self-propelled_vehicle>thing).@indef)\n",
+    "obj(next(icl>adj,equ>adjacent).@not.@present,train(icl>public_transport>thing).@def)\n",
+    "man(next(icl>adj,equ>adjacent).@not.@present,reverse(icl>change>do,agt>thing,obj>thing):02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The operative cab of a train set will be an integral part of that train set. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(cab(icl>compartment>thing).@def,operative(icl>adj,ant>inoperative))\n",
+    "aoj(part(icl>region>abstract_thing,pof>area).@entry.@indef.@future,cab(icl>compartment>thing).@def)\n",
+    "mod(cab(icl>compartment>thing).@def,train(icl>public_transport>thing):01.@indef)\n",
+    "obj(set(icl>displace>do,agt>thing,obj>thing,plc>uw):01.@state,train(icl>public_transport>thing):01.@indef)\n",
+    "mod(part(icl>region>abstract_thing,pof>area).@entry.@indef.@future,integral(icl>adj,equ>built-in))\n",
+    "mod(train(icl>public_transport>thing):02,that(icl>determiner>adj,com>remote,mod<concrete_thing))\n",
+    "pof(part(icl>region>abstract_thing,pof>area).@entry.@indef.@future,train(icl>public_transport>thing):02)\n",
+    "obj(set(icl>displace>do,agt>thing,obj>thing,plc>uw):02.@state,train(icl>public_transport>thing):02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In both cases the master switch is in Reverse. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "qua(case(icl>happening>thing).@pl,both(icl>quantity,com>two,qua<thing))\n",
+    "scn(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,case(icl>happening>thing).@pl)\n",
+    "mod(switch(icl>control>thing).@def,master)\n",
+    "aoj(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,switch(icl>control>thing).@def)\n",
+    "plc(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,reverse(icl>opposition>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track section prepared for train operation.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track section prepared for train operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(section(icl>writing>thing),track(icl>line>thing,equ>path))\n",
+    "agt(prepare(icl>train>do,agt>person,obj>thing,pur>thing).@entry.@past,section(icl>writing>thing))\n",
+    "mod(operation(icl>business_activity>thing),train(icl>public_transport>thing))\n",
+    "pur(prepare(icl>train>do,agt>person,obj>thing,pur>thing).@entry.@past,operation(icl>business_activity>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A data base providing infrastructure data required for train operation.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A data base providing infrastructure data required for train operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(base(icl>abstract_thing,equ>basis,obj>uw).@indef,data(icl>collection>thing):01)\n",
+    "agt(perform_an_action(icl>do,agt>thing,obj>process).@progress,base(icl>abstract_thing,equ>basis,obj>uw).@indef)\n",
+    "aoj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@past,base(icl>abstract_thing,equ>basis,obj>uw).@indef)\n",
+    "mod(data(icl>collection>thing):02,infrastructure(icl>structure>thing))\n",
+    "obj(perform_an_action(icl>do,agt>thing,obj>process).@progress,data(icl>collection>thing):02)\n",
+    "plt(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@past,train(icl>public_transport>thing))\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@past,operation(icl>business_activity>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Distance between the end of a movement authority and the first possible danger point.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Distance between the end of a movement authority and the first possible danger point. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(danger(icl>condition>thing,ant>safety).@def,distance(icl>spacing>thing))\n",
+    "plc(distance(icl>spacing>thing),between(icl>how,obj>thing,plc<uw))\n",
+    "obj(between(icl>how,obj>thing,plc<uw),end(icl>moment>time,ant>beginning).@def)\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@indef,movement(icl>happening>thing))\n",
+    "agt(end(icl>moment>time,ant>beginning).@def,authority(icl>abstract_thing,obj>uw).@indef)\n",
+    "mod(danger(icl>condition>thing,ant>safety).@def,first(icl>adj,ant>last))\n",
+    "mod(danger(icl>condition>thing,ant>safety).@def,possible(icl>adj,ant>impossible))\n",
+    "aoj(point(icl>indicate>be,obj>thing,aoj>thing).@entry.@present,danger(icl>condition>thing,ant>safety).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A shunting movement, in which the driver is situated in the leading vehicle. Hauling forward the master switch in the operative cab is in Forward for this operation. Hauling reverse the master switch in the operative cab is in Reverse for this operation.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A shunting movement, in which the driver is situated in the leading vehicle. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing).@progress,movement(icl>happening>thing).@entry.@indef)\n",
+    "mod(situate(icl>set>do,plt>thing,agt>person,obj>thing).@present,movement(icl>happening>thing).@entry.@indef)\n",
+    "plc(lead(icl>induce>do,agt>thing,obj>volitional_thing,gol>uw).@progress,which)\n",
+    "obj(situate(icl>set>do,plt>thing,agt>person,obj>thing).@present,driver(icl>operator>thing,ant>nondriver).@def.@topic)\n",
+    "plc(situate(icl>set>do,plt>thing,agt>person,obj>thing).@present,vehicle(icl>functional_thing,pur>thing).@def)\n",
+    "agt(lead(icl>induce>do,agt>thing,obj>volitional_thing,gol>uw).@progress,vehicle(icl>functional_thing,pur>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Hauling forward the master switch in the operative cab is in Forward for this operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man:01(haul(icl>draw(icl>move)>do,agt>thing,obj>concrete_thing).@entry,forward(icl>how,ant>backward))\n",
+    "mod:01(switch(icl>control>thing).@def,master)\n",
+    "obj:01(haul(icl>draw(icl>move)>do,agt>thing,obj>concrete_thing).@entry,switch(icl>control>thing).@def)\n",
+    "mod:01(cab(icl>compartment>thing).@def,operative(icl>adj,ant>inoperative))\n",
+    "plc:01(switch(icl>control>thing).@def,cab(icl>compartment>thing).@def)\n",
+    "plc(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,forward(icl>position>thing).@maiuscul)\n",
+    "mod(operation(icl>business_activity>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "pur(forward(icl>position>thing).@maiuscul,operation(icl>business_activity>thing))\n",
+    "aoj(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Hauling reverse the master switch in the operative cab is in Reverse for this operation. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(haul(icl>draw(icl>move)>do,agt>thing,obj>concrete_thing).@progress,reverse(icl>opposition>thing):01)\n",
+    "aoj(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,reverse(icl>opposition>thing):01)\n",
+    "obj(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,master)\n",
+    "fictit(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,switch(icl>control>thing))\n",
+    "mod(cab(icl>compartment>thing).@def,operative(icl>adj,ant>inoperative))\n",
+    "plc(switch(icl>control>thing),cab(icl>compartment>thing).@def)\n",
+    "plc(be(icl>be,equ>be_located,aoj>thing,plc>uw).@entry.@present,reverse(icl>opposition>thing):02.@maiuscul)\n",
+    "mod(operation(icl>business_activity>thing),this(icl>determiner>adj,mod<concrete_thing))\n",
+    "pur(reverse(icl>opposition>thing):02.@maiuscul,operation(icl>business_activity>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A shunting movement, in which the driver is not situated in the leading vehicle. See also propelling.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A shunting movement, in which the driver is not situated in the leading vehicle. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing).@progress,movement(icl>happening>thing).@entry.@indef)\n",
+    "mod(situate(icl>set>do,plt>thing,agt>person,obj>thing).@not.@present,movement(icl>happening>thing).@entry.@indef)\n",
+    "plc(lead(icl>induce>do,agt>thing,obj>volitional_thing,gol>uw).@progress,which)\n",
+    "obj(situate(icl>set>do,plt>thing,agt>person,obj>thing).@not.@present,driver(icl>operator>thing,ant>nondriver).@def.@topic)\n",
+    "plc(situate(icl>set>do,plt>thing,agt>person,obj>thing).@not.@present,vehicle(icl>functional_thing,pur>thing).@def)\n",
+    "agt(lead(icl>induce>do,agt>thing,obj>volitional_thing,gol>uw).@progress,vehicle(icl>functional_thing,pur>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "See also propelling. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(propel(icl>move>do,agt>thing,obj>thing),also(icl>how,equ>besides))\n",
+    "obj(see(icl>perceive>be,cob>uw,obj>thing,aoj>thing).@entry.@imperative,propel(icl>move>do,agt>thing,obj>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When vehicles are moved without train data available.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When vehicles are moved without train data available. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing).@pl.@present,vehicle(icl>functional_thing,pur>thing).@pl.@topic)\n",
+    "obj(when(icl>how,tim<uw,obj>uw).@entry,move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing).@pl.@present)\n",
+    "man(move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing).@pl.@present,without(icl>how,ant>with,com>physical,obj>thing))\n",
+    "mod(data(icl>collection>thing),train(icl>public_transport>thing))\n",
+    "mod(data(icl>collection>thing),available(icl>adj,ant>unavailable))\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing),data(icl>collection>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A fixed signal intended for shunting movements. In some cases Shunting signals at \"danger\" are valid also for train movements.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A fixed signal intended for shunting movements. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,signal(icl>communication>thing).@indef)\n",
+    "aoj(intend(icl>will>be,obj>uw,aoj>person).@entry.@past,signal(icl>communication>thing).@indef)\n",
+    "obj:01(shunt(icl>transfer>do,agt>thing,obj>thing).@entry,movement(icl>happening>thing).@pl)\n",
+    "pur(intend(icl>will>be,obj>uw,aoj>person).@entry.@past,:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "In some cases Shunting signals at \"danger\" are valid also for train movements. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(case(icl>happening>thing).@pl,some(icl>adj))\n",
+    "agt(shunt(icl>transfer>do,agt>thing,obj>thing).@progress.@maiuscul,case(icl>happening>thing).@pl)\n",
+    "scn(be(icl>be).@entry.@pl.@present,case(icl>happening>thing).@pl)\n",
+    "obj(shunt(icl>transfer>do,agt>thing,obj>thing).@progress.@maiuscul,signal(icl>communication>thing).@pl)\n",
+    "tim(signal(icl>communication>thing).@pl,danger(icl>condition>thing,ant>safety).@double_quote)\n",
+    "mod(movement(icl>happening>thing).@pl,valid(icl>adj,ant>invalid))\n",
+    "man(train(icl>public_transport>thing),also(icl>how,equ>besides))\n",
+    "obj(valid(icl>adj,ant>invalid),train(icl>public_transport>thing))\n",
+    "aoj(be(icl>be).@entry.@pl.@present,movement(icl>happening>thing).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS System Requirements Specification document.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS System Requirements Specification document. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(system(icl>group>thing).@maiuscul,etcs)\n",
+    "mod(requirement(icl>duty>thing).@pl.@maiuscul,system(icl>group>thing).@maiuscul)\n",
+    "mod(specification(icl>description>thing).@maiuscul,requirement(icl>duty>thing).@pl.@maiuscul)\n",
+    "mod(document(icl>writing>thing).@entry.@def,specification(icl>description>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Permanent speed restrictions for a part of track sent from track to train.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Permanent speed restrictions for a part of track sent from track to train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(restriction(icl>rule>thing).@pl,permanent(icl>adj,ant>impermanent))\n",
+    "mod(restriction(icl>rule>thing).@pl,speed(icl>rate>thing))\n",
+    "agt(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing).@entry.@past,restriction(icl>rule>thing).@pl)\n",
+    "pur(restriction(icl>rule>thing).@pl,part(icl>region>abstract_thing,pof>area).@indef)\n",
+    "pof(part(icl>region>abstract_thing,pof>area).@indef,track(icl>line>thing,equ>path):01)\n",
+    "plf(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing).@entry.@past,track(icl>line>thing,equ>path):02)\n",
+    "pur(send(icl>direct>do,plt>uw,plf>thing,agt>volitional_thing,obj>thing,rec>thing).@entry.@past,train(icl>practice>do,agt>person,obj>person,gol>uw))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Where there can be points (facing or trailing) that makes it possible for the train to use different routes. (Not identical with the BR definition).\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Where there can be points (facing or trailing) that makes it possible for the train to use different routes. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc:02(be(icl>be).@entry.@present.@ability,where(icl>how,plc<uw))\n",
+    "aoj:02(be(icl>be).@entry.@present.@ability,point(icl>component>thing).@pl)\n",
+    "or:01(trail(icl>drag>occur,plt>thing,plf>thing,cob>concrete_thing,obj>concrete_thing),face(icl>do,equ>confront,agt>volitional_thing,cag>thing,met>thing))\n",
+    "agt(make(icl>do,equ>do,agt>volitional_thing,obj>action,ins>thing).@entry.@present,that(icl>thing,equ>it,equ>this))\n",
+    "man(make(icl>do,equ>do,agt>volitional_thing,obj>action,ins>thing).@entry.@present,possible(icl>adj,ant>impossible))\n",
+    "plt:03(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry,train(icl>public_transport>thing).@def)\n",
+    "mod:03(route(icl>line>thing,equ>path).@pl,different(icl>adj,ant>same))\n",
+    "obj:03(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry,route(icl>line>thing,equ>path).@pl)\n",
+    "shd:02(point(icl>component>thing).@pl,:01.@parenthesis)\n",
+    "obj(make(icl>do,equ>do,agt>volitional_thing,obj>action,ins>thing).@entry.@present,:03)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "(Not identical with the BR definition). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:01(definition(icl>explanation>thing).@def,br)\n",
+    "obj:01(identical(icl>adj).@entry.@not,definition(icl>explanation>thing).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Specific Transmission Module\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Specific Transmission Module. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(module(icl>component>thing).@entry.@maiuscul,specific(icl>adj,equ>particular,ant>general))\n",
+    "mod(module(icl>component>thing).@entry.@maiuscul,transmission(icl>sending>thing).@maiuscul)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Position, from where no movement authority is given to a train, not necessarily a fixed signal.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Position, from where no movement authority is given to a train, not necessarily a fixed signal. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "plc(give(icl>do,equ>hand_over,agt>living_thing,obj>concrete_thing,rec>person).@present,position(icl>place,aoj>thing,plc>thing).@entry)\n",
+    "mod(movement(icl>happening>thing),no(icl>quantity,qua<thing))\n",
+    "mod(authority(icl>abstract_thing,obj>uw).@topic,movement(icl>happening>thing))\n",
+    "obj(give(icl>do,equ>hand_over,agt>living_thing,obj>concrete_thing,rec>person).@present,authority(icl>abstract_thing,obj>uw).@topic)\n",
+    "and(signal(icl>communication>thing).@indef,train(icl>public_transport>thing).@indef)\n",
+    "man(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,necessarily(icl>how,ant>unnecessarily,com>necessary).@not)\n",
+    "rec(give(icl>do,equ>hand_over,agt>living_thing,obj>concrete_thing,rec>person).@present,signal(icl>communication>thing).@indef)\n",
+    "obj(fix(icl>improve>do,equ>repair,agt>person,obj>functional_thing,ins>thing).@state,signal(icl>communication>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "The ETCS Sub-System Requirements Specifications (e.g. ETCS cab, ETCS balise, ETCS radio)\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "The ETCS Sub-System Requirements Specifications (e.g. ETCS cab, ETCS balise, ETCS radio). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(system(icl>group>thing).@maiuscul,etcs:01)\n",
+    "mod(system(icl>group>thing).@maiuscul,sub.@maiuscul)\n",
+    "mod(requirement(icl>duty>thing).@pl.@maiuscul,system(icl>group>thing).@maiuscul)\n",
+    "mod(specification(icl>description>thing).@entry.@def.@pl.@maiuscul,requirement(icl>duty>thing).@pl.@maiuscul)\n",
+    "man:01(etcs:02,\"e.g.\"(icl>how,equ>for_example))\n",
+    "agt:01(cab(icl>ride>do,equ>taxi,agt>thing).@present,etcs:02)\n",
+    "and:01(radio(icl>transmit>do,agt>volitional_thing,obj>information,rec>thing).@present,cab(icl>ride>do,equ>taxi,agt>thing).@present)\n",
+    "mod(:02.@_hn-scope,etcs:03)\n",
+    "and:02(etcs:04.@entry,balise.@entry)\n",
+    "shd(specification(icl>description>thing).@entry.@def.@pl.@maiuscul,:01.@parenthesis)\n",
+    "agt(radio(icl>transmit>do,agt>volitional_thing,obj>information,rec>thing).@present,:02.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Two or more traction units, mechanically and pneumatically but not electrically coupled together, used in the same train. Each traction unit requires a separate driver.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Two or more traction units, mechanically and pneumatically but not electrically coupled together, used in the same train. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or(more(icl>how),two(icl>digit>thing))\n",
+    "qua(unit(icl>measure>abstract_thing,aoj>uw).@pl,more(icl>how))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@pl,traction(icl>pull>thing))\n",
+    "obj(couple together.@state,unit(icl>measure>abstract_thing,aoj>uw).@pl)\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw),unit(icl>measure>abstract_thing,aoj>uw).@pl)\n",
+    "agt(train(icl>practice>do,agt>person,obj>person,gol>uw).@entry.@present,unit(icl>measure>abstract_thing,aoj>uw).@pl)\n",
+    "and(pneumatically(icl>how,com>pneumatic),mechanically(icl>how,com>mechanical))\n",
+    "obj(but(icl>how,equ>however,obj>uw,and<uw),pneumatically(icl>how,com>pneumatic))\n",
+    "man(couple together.@state,pneumatically(icl>how,com>pneumatic))\n",
+    "and(electrically(icl>how,com>electric).@not,but(icl>how,equ>however,obj>uw,and<uw))\n",
+    "plc(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw),same(icl>adj,ant>other).@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Each traction unit requires a separate driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw),each(icl>quantity,per>thing))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw),traction(icl>pull>thing))\n",
+    "aoj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present,unit(icl>measure>abstract_thing,aoj>uw))\n",
+    "mod(driver(icl>operator>thing,ant>nondriver).@indef,separate(icl>adj,ant>joint))\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@entry.@present,driver(icl>operator>thing,ant>nondriver).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Location where any ETCS information changes or intermittent transmission is expected.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Location where any ETCS information changes or intermittent transmission is expected. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "or:01(transmission(icl>sending>thing).@entry,location(icl>object>thing).@entry.@topic)\n",
+    "mod(information(icl>message>thing),any(icl>adj))\n",
+    "mod(information(icl>message>thing),etcs)\n",
+    "obj(change(icl>occur,src>thing,obj>thing,gol>thing).@present,information(icl>message>thing))\n",
+    "mod(:01.@_hn-scope,intermittent(icl>adj))\n",
+    "obj(expect(icl>evaluate>be,src>thing,obj>uw,aoj>thing).@entry.@present,transmission(icl>sending>thing).@entry)\n",
+    "plc(change(icl>occur,src>thing,obj>thing,gol>thing).@present,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Speed restriction on behalf of planned, temporary conditions, e.g. track maintenance.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Speed restriction on behalf of planned, temporary conditions, e.g. track maintenance. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(restriction(icl>rule>thing).@entry,speed(icl>rate>thing))\n",
+    "plc(restriction(icl>rule>thing).@entry,behalf(icl>stead>thing))\n",
+    "mod:01(condition(icl>state>abstract_thing,aoj>thing).@entry.@pl,temporary(icl>adj,equ>impermanent,ant>permanent))\n",
+    "obj:01(plan(icl>intend>be,tim>uw,obj>uw,aoj>thing).@state,condition(icl>state>abstract_thing,aoj>thing).@entry.@pl)\n",
+    "man:01(track(icl>mark>do,agt>thing,obj>thing),\"e.g.\"(icl>how,equ>for_example))\n",
+    "obj:01(plan(icl>intend>be,tim>uw,obj>uw,aoj>thing).@state,track(icl>mark>do,agt>thing,obj>thing))\n",
+    "obj:01(track(icl>mark>do,agt>thing,obj>thing),maintenance(icl>repair>thing,equ>care))\n",
+    "obj(behalf(icl>stead>thing),:01)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Vehicle with driving cab(s) from where a movement may be operated.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Vehicle with driving cab(s) from where a movement may be operated. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "met(vehicle(icl>functional_thing,pur>thing).@entry,drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing))\n",
+    "obj(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing),cab(icl>compartment>thing))\n",
+    "cnt(cab(icl>compartment>thing),s.@parenthesis)\n",
+    "plc(operate(icl>manage>do,agt>volitional_thing,obj>thing).@present.@grant,where(icl>how,plc<uw))\n",
+    "obj(operate(icl>manage>do,agt>volitional_thing,obj>thing).@present.@grant,movement(icl>happening>thing).@indef.@topic)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Trackside device used for track free/occupied determination.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Trackside device used for track free/occupied determination. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(device(icl>instrumentality>thing),trackside)\n",
+    "agt(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry.@past,device(icl>instrumentality>thing))\n",
+    "pur(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry.@past,track(icl>line>thing,equ>path))\n",
+    "mod(determination(icl>quality>abstract_thing,obj>uw,aoj>person),free(icl>adj,ant>unfree))\n",
+    "obj(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry.@past,determination(icl>quality>abstract_thing,obj>uw,aoj>person))\n",
+    "obj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@state,determination(icl>quality>abstract_thing,obj>uw,aoj>person))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Determination of a track section not occupied by any railway vehicle. Determination is traditionally based on track circuits or axle counters, but may on ETCS equipped lines be replaced by train location and train Integrity functions.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Determination of a track section not occupied by any railway vehicle. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@entry.@past.@not,determination(icl>quality>abstract_thing,obj>uw,aoj>person))\n",
+    "mod(section(icl>writing>thing).@indef,track(icl>line>thing,equ>path))\n",
+    "agt(determination(icl>quality>abstract_thing,obj>uw,aoj>person),section(icl>writing>thing).@indef)\n",
+    "mod(railway(icl>line>thing),any(icl>adj))\n",
+    "met(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@entry.@past.@not,railway(icl>line>thing))\n",
+    "obj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@entry.@past.@not,vehicle(icl>functional_thing,pur>thing))\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Determination is traditionally based on track circuits or axle counters, but may on ETCS equipped lines be replaced by train location and train Integrity functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present,determination(icl>quality>abstract_thing,obj>uw,aoj>person).@topic)\n",
+    "obj(:03.@_hn-scope,base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present)\n",
+    "man(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present,traditionally(icl>how,com>traditional))\n",
+    "mod:01(circuit(icl>electrical_device>thing).@entry.@pl,track(icl>line>thing,equ>path))\n",
+    "or:01(counter(icl>table>thing).@entry.@pl,circuit(icl>electrical_device>thing).@entry.@pl)\n",
+    "mod(circuit(icl>electrical_device>thing).@entry.@pl,axle(icl>shaft>thing))\n",
+    "and:03(replace(icl>do,equ>substitute,cob>thing,obj>thing).@entry.@present.@grant,but(icl>how,equ>however,obj>uw,and<uw).@entry)\n",
+    "plc(but(icl>how,equ>however,obj>uw,and<uw).@entry,on(icl>how,com>surface,obj>concrete_thing,plc<uw))\n",
+    "man(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,etcs)\n",
+    "obj(on(icl>how,com>surface,obj>concrete_thing,plc<uw),line(icl>formation>thing).@pl)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,line(icl>formation>thing).@pl)\n",
+    "mod:05(location(icl>object>thing).@entry,train(icl>public_transport>thing):01)\n",
+    "and:05(function(icl>mathematical_relation>thing).@entry.@pl,location(icl>object>thing).@entry)\n",
+    "mod(integrity(icl>state>thing).@maiuscul,train(icl>public_transport>thing):02)\n",
+    "mod(location(icl>object>thing).@entry,integrity(icl>state>thing).@maiuscul)\n",
+    "cob(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present,:01.@_hn-scope)\n",
+    "cob:03(replace(icl>do,equ>substitute,cob>thing,obj>thing).@entry.@present.@grant,:05.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Track occupied by railway vehicle(s). Determination is traditionally based on track circuits or axle counters, but may on ETCS equipped lines be replaced by train location and train integrity functions. Because of the fail safe construction track occupied could mean: track not determined free.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Track occupied by railway vehicle(s). \n",
+    "{/org}\n",
+    "{unl}\n",
+    "aoj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@entry.@past,track(icl>line>thing,equ>path))\n",
+    "mod(vehicle(icl>functional_thing,pur>thing),railway(icl>line>thing))\n",
+    "met(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@entry.@past,vehicle(icl>functional_thing,pur>thing))\n",
+    "cnt(vehicle(icl>functional_thing,pur>thing),s.@parenthesis)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Determination is traditionally based on track circuits or axle counters, but may on ETCS equipped lines be replaced by train location and train integrity functions. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present,determination(icl>quality>abstract_thing,obj>uw,aoj>person).@topic)\n",
+    "obj(:03.@_hn-scope,base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present)\n",
+    "man(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present,traditionally(icl>how,com>traditional))\n",
+    "mod:01(circuit(icl>electrical_device>thing).@entry.@pl,track(icl>line>thing,equ>path))\n",
+    "or:01(counter(icl>table>thing).@entry.@pl,circuit(icl>electrical_device>thing).@entry.@pl)\n",
+    "mod(circuit(icl>electrical_device>thing).@entry.@pl,axle(icl>shaft>thing))\n",
+    "and:03(replace(icl>do,equ>substitute,cob>thing,obj>thing).@entry.@present.@grant,but(icl>how,equ>however,obj>uw,and<uw).@entry)\n",
+    "plc(but(icl>how,equ>however,obj>uw,and<uw).@entry,on(icl>how,com>surface,obj>concrete_thing,plc<uw))\n",
+    "man(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,etcs)\n",
+    "obj(on(icl>how,com>surface,obj>concrete_thing,plc<uw),line(icl>formation>thing).@pl)\n",
+    "obj(equip(icl>furnish>do,agt>person,obj>thing,ins>concrete_thing).@state,line(icl>formation>thing).@pl)\n",
+    "mod:05(location(icl>object>thing).@entry,train(icl>public_transport>thing):01)\n",
+    "and:05(function(icl>mathematical_relation>thing).@entry.@pl,location(icl>object>thing).@entry)\n",
+    "mod(integrity(icl>state>thing),train(icl>public_transport>thing):02)\n",
+    "mod(location(icl>object>thing).@entry,integrity(icl>state>thing))\n",
+    "cob(base(icl>ground>do,cob>thing,agt>volitional_thing,obj>thing).@entry.@present,:01.@_hn-scope)\n",
+    "cob:03(replace(icl>do,equ>substitute,cob>thing,obj>thing).@entry.@present.@grant,:05.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Because of the fail safe construction track occupied could mean: track not determined free. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(safe(icl>strongbox>thing).@def,fail(icl>disappoint>occur,cob>thing,obj>thing))\n",
+    "rsn(ability(icl>modal>be,obj>uw,aoj>thing).@entry,safe(icl>strongbox>thing).@def)\n",
+    "mod(track(icl>line>thing,equ>path),construction(icl>creating_from_raw_materials>thing))\n",
+    "obj(occupy(icl>be>be,equ>inhabit,obj>thing,aoj>thing).@state,track(icl>line>thing,equ>path))\n",
+    "aoj(ability(icl>modal>be,obj>uw,aoj>thing).@entry,track(icl>line>thing,equ>path))\n",
+    "aoj(mean(icl>necessitate>be,equ>entail,obj>uw,aoj>uw),track(icl>line>thing,equ>path))\n",
+    "obj(ability(icl>modal>be,obj>uw,aoj>thing).@entry,mean(icl>necessitate>be,equ>entail,obj>uw,aoj>uw))\n",
+    "man:02(determine(icl>cause>be,equ>shape,obj>thing,aoj>thing).@entry.@not,free(icl>adj,ant>unfree))\n",
+    "obj(mean(icl>necessitate>be,equ>entail,obj>uw,aoj>uw),:01)\n",
+    "man:01(track(icl>mark>do,agt>thing,obj>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Transmission of ETCS information from any trackside equipment to a train via balise, loop, radio or other media. Using intermittent transmission (balise or loop) the information can only be transmitted to a train passing the transmission unit.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Transmission of ETCS information from any trackside equipment to a train via balise, loop, radio or other media. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(information(icl>message>thing),etcs)\n",
+    "obj(transmission(icl>sending>thing).@entry,information(icl>message>thing))\n",
+    "mod(equipment(icl>instrumentality>thing),any(icl>adj))\n",
+    "mod(equipment(icl>instrumentality>thing),trackside)\n",
+    "man(transmission(icl>sending>thing).@entry,equipment(icl>instrumentality>thing))\n",
+    "mod(via,train(icl>public_transport>thing))\n",
+    "mod(:01.@_hn-scope,via)\n",
+    "or:01(loop(icl>fastener>thing,equ>cringle).@entry,balise.@entry.@indef)\n",
+    "or:01(radio(icl>media>abstract_thing).@entry,loop(icl>fastener>thing,equ>cringle).@entry)\n",
+    "mod(medium(icl>instrumentality>thing).@pl,other(icl>adj,equ>different))\n",
+    "man(transmission(icl>sending>thing).@entry,medium(icl>instrumentality>thing).@pl)\n",
+    "or(medium(icl>instrumentality>thing).@pl,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Using intermittent transmission (balise or loop) the information can only be transmitted to a train passing the transmission unit. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:02(transmission(icl>sending>thing):01,intermittent(icl>adj))\n",
+    "obj:02(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry,transmission(icl>sending>thing):01)\n",
+    "or:01(loop(icl>fastener>thing,equ>cringle),balise)\n",
+    "obj(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),information(icl>message>thing).@def.@topic)\n",
+    "man(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),only(icl>how,com>result))\n",
+    "obj(ability(icl>modal>be,obj>uw,aoj>thing).@entry,transmit(icl>pass>do,agt>thing,obj>thing,ben>thing))\n",
+    "ben(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),train(icl>public_transport>thing).@indef)\n",
+    "agt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@continue,train(icl>public_transport>thing).@indef)\n",
+    "plt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@continue,transmission(icl>sending>thing):02.@def)\n",
+    "plc(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@continue,unit(icl>measure>abstract_thing,aoj>uw))\n",
+    "nam:02(transmission(icl>sending>thing):01,:01.@parenthesis)\n",
+    "man(ability(icl>modal>be,obj>uw,aoj>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "A traction unit with or without coupled railway vehicles or a train set of vehicles with ETCS train data available.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "A traction unit with or without coupled railway vehicles or a train set of vehicles with ETCS train data available. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@entry.@indef,traction(icl>pull>thing))\n",
+    "or(without(icl>how,ant>with,com>physical,obj>thing),with(icl>how,com>possession,obj>thing,mod<thing):01)\n",
+    "mod(:01.@_hn-scope,railway(icl>line>thing))\n",
+    "or:01(train(icl>public_transport>thing):01.@entry.@indef,vehicle(icl>functional_thing,pur>thing):01.@entry.@pl)\n",
+    "obj(couple(icl>join>do,equ>match,cob>thing,agt>thing,obj>thing).@state,train(icl>public_transport>thing):01.@entry.@indef)\n",
+    "obj(set(icl>displace>do,agt>thing,obj>thing,plc>uw).@state,train(icl>public_transport>thing):01.@entry.@indef)\n",
+    "pur:01(vehicle(icl>functional_thing,pur>thing):01.@entry.@pl,vehicle(icl>functional_thing,pur>thing):02.@pl)\n",
+    "mod:01(vehicle(icl>functional_thing,pur>thing):02.@pl,with(icl>how,com>possession,obj>thing,mod<thing):02)\n",
+    "mod:01(train(icl>public_transport>thing):02,etcs)\n",
+    "mod:01(data(icl>collection>thing),train(icl>public_transport>thing):02)\n",
+    "mod:01(data(icl>collection>thing),available(icl>adj,ant>unavailable))\n",
+    "obj:01(with(icl>how,com>possession,obj>thing,mod<thing):02,data(icl>collection>thing))\n",
+    "mod(unit(icl>measure>abstract_thing,aoj>uw).@entry.@indef,)\n",
+    "obj(without(icl>how,ant>with,com>physical,obj>thing),)\n",
+    "obj(with(icl>how,com>possession,obj>thing,mod<thing):01,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Data that characterises a train and which is required by ETCS in order to supervise a train movement\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Data that characterises a train and which is required by ETCS in order to supervise a train movement. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "agt(characterize(icl>do,equ>describe,cob>thing,agt>person,obj>thing,ben>person).@present,data(icl>collection>thing).@entry)\n",
+    "and(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@present,characterize(icl>do,equ>describe,cob>thing,agt>person,obj>thing,ben>person).@present)\n",
+    "obj(characterize(icl>do,equ>describe,cob>thing,agt>person,obj>thing,ben>person).@present,train(icl>public_transport>thing):01.@indef)\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@present,which.@topic)\n",
+    "agt(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@present,etcs)\n",
+    "pur(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@present,in_order_to(icl>how,obj>uw,pur<uw))\n",
+    "obj(in_order_to(icl>how,obj>uw,pur<uw),supervise(icl>control>do,agt>volitional_thing,obj>thing))\n",
+    "mod(movement(icl>happening>thing).@indef,train(icl>public_transport>thing):02)\n",
+    "obj(supervise(icl>control>do,agt>volitional_thing,obj>thing),movement(icl>happening>thing).@indef)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Tables in the trainborne ETCS equipment for the countries to be selected according to national rules.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Tables in the trainborne ETCS equipment for the countries to be selected according to national rules. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(etcs,trainborne)\n",
+    "mod(equipment(icl>instrumentality>thing).@def,etcs)\n",
+    "plc(table(icl>place>abstract_thing,com>restaurant).@entry.@pl,equipment(icl>instrumentality>thing).@def)\n",
+    "plc(equipment(icl>instrumentality>thing).@def,country(icl>place).@def.@pl)\n",
+    "pur(country(icl>place).@def.@pl,select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw))\n",
+    "src(select(icl>choose>do,src>thing,agt>thing,obj>uw,gol>uw),according_to(icl>how,src>uw,obj>uw))\n",
+    "mod(rule(icl>practice>thing,equ>convention).@pl,national(icl>adj,ant>international))\n",
+    "obj(according_to(icl>how,src>uw,obj>uw),rule(icl>practice>thing,equ>convention).@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When vehicles are moved with train data available, as a rule from station to station, and as a rule under the authority of \"proceed\" aspects from main signals, or similar procedures.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When vehicles are moved with train data available, as a rule from station to station, and as a rule under the authority of \"proceed\" aspects from main signals, or similar procedures. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing).@pl.@present,vehicle(icl>functional_thing,pur>thing).@pl.@topic)\n",
+    "obj(when(icl>how,tim<uw,obj>uw).@entry,move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing).@pl.@present)\n",
+    "man(move(icl>relocate>do,plt>thing,plf>thing,agt>volithional_thing).@pl.@present,with(icl>how,com>carry,obj>concrete_thing,man<uw))\n",
+    "mod(data(icl>collection>thing),train(icl>public_transport>thing))\n",
+    "obj(with(icl>how,com>carry,obj>concrete_thing,man<uw),data(icl>collection>thing))\n",
+    "mod(data(icl>collection>thing),available(icl>adj,ant>unavailable))\n",
+    "and(as(icl>how,com>degree,obj>uw,man<uw):02,as(icl>how,com>degree,obj>uw,man<uw):01)\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw):01,rule(icl>practice>thing,equ>convention):01.@indef)\n",
+    "mod(rule(icl>practice>thing,equ>convention):01.@indef,from(icl>how,equ>according_to,obj>thing))\n",
+    "obj(from(icl>how,equ>according_to,obj>thing),station(icl>facility>thing))\n",
+    "pur(station(icl>facility>thing),station(icl>move>do,agt>volitional_thing,obj>concrete_thing,plc>thing))\n",
+    "man(available(icl>adj,ant>unavailable),rule(icl>practice>thing,equ>convention):02.@indef)\n",
+    "obj(as(icl>how,com>degree,obj>uw,man<uw):02,rule(icl>practice>thing,equ>convention):02.@indef)\n",
+    "plc(rule(icl>practice>thing,equ>convention):02.@indef,under(icl>how,equ>below,obj>thing,plc<uw))\n",
+    "obj(under(icl>how,equ>below,obj>thing,plc<uw),authority(icl>abstract_thing,obj>uw).@def)\n",
+    "mod(aspect(icl>feature>thing).@pl,proceed(icl>talk>do,equ>continue,plf>thing,agt>person,obj>action).@double_quote)\n",
+    "obj(authority(icl>abstract_thing,obj>uw).@def,aspect(icl>feature>thing).@pl)\n",
+    "mod:01(signal(icl>communication>thing).@entry.@pl,main(icl>adj,equ>chief))\n",
+    "or:01(procedure(icl>activity>thing).@entry.@pl,signal(icl>communication>thing).@entry.@pl)\n",
+    "mod(signal(icl>communication>thing).@entry.@pl,similar(icl>adj,ant>dissimilar))\n",
+    "rsn(aspect(icl>feature>thing).@pl,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Transmission of ETCS information from a train to any trackside equipment via balise, loop, radio or other media. Using intermittent transmission (balise or short loop) the information can only be transmitted from a train passing the transmission unit.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Transmission of ETCS information from a train to any trackside equipment via balise, loop, radio or other media. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod(information(icl>message>thing),etcs)\n",
+    "obj(transmission(icl>sending>thing).@entry,information(icl>message>thing))\n",
+    "plc(transmission(icl>sending>thing).@entry,train(icl>public_transport>thing).@indef)\n",
+    "mod(:01.@_hn-scope,any(icl>adj))\n",
+    "mod:01(equipment(icl>instrumentality>thing),trackside)\n",
+    "mod:01(via,equipment(icl>instrumentality>thing))\n",
+    "mod:01(balise.@entry,via)\n",
+    "or:01(loop(icl>fastener>thing,equ>cringle).@entry,balise.@entry)\n",
+    "or:01(radio(icl>media>abstract_thing).@entry,loop(icl>fastener>thing,equ>cringle).@entry)\n",
+    "mod(medium(icl>instrumentality>thing).@pl,other(icl>adj,equ>different))\n",
+    "man(train(icl>public_transport>thing).@indef,medium(icl>instrumentality>thing).@pl)\n",
+    "or(medium(icl>instrumentality>thing).@pl,:01.@_hn-scope)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Using intermittent transmission (balise or short loop) the information can only be transmitted from a train passing the transmission unit. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "mod:02(transmission(icl>sending>thing):01,intermittent(icl>adj))\n",
+    "obj:02(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw).@entry,transmission(icl>sending>thing):01)\n",
+    "or:03(loop(icl>fastener>thing,equ>cringle).@entry,balise.@entry)\n",
+    "mod(:03.@_hn-scope,short(icl>adj,ant>long,com>length))\n",
+    "obj(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),information(icl>message>thing).@def.@topic)\n",
+    "man(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),only(icl>how,com>result))\n",
+    "obj(ability(icl>modal>be,obj>uw,aoj>thing).@entry,transmit(icl>pass>do,agt>thing,obj>thing,ben>thing))\n",
+    "plf(transmit(icl>pass>do,agt>thing,obj>thing,ben>thing),train(icl>public_transport>thing).@indef)\n",
+    "agt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@continue,train(icl>public_transport>thing).@indef)\n",
+    "plt(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@continue,transmission(icl>sending>thing):02.@def)\n",
+    "plc(pass(icl>cross>do,via>thing,plt>thing,plf>thing,agt>thing,plc>thing).@continue,unit(icl>measure>abstract_thing,aoj>uw))\n",
+    "man(ability(icl>modal>be,obj>uw,aoj>thing).@entry,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Is used when a train passes a \"danger\" signal, excluding any occasion when a suppress facility is used, and causes an immediate application of the emergency brake.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Is used when a train passes a \"danger\" signal, excluding any occasion when a suppress facility is used, and causes an immediate application of the emergency brake. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(:02,use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw):01.@entry.@present)\n",
+    "tim(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw):01.@entry.@present,when(icl>how,com>always,tim<uw,obj>uw))\n",
+    "mod(pass(icl>accomplishment>thing,equ>base_on_balls).@pl,train(icl>public_transport>thing).@indef)\n",
+    "agt(signal(icl>signalize>do,agt>person,obj>thing,rec>person).@present,pass(icl>accomplishment>thing,equ>base_on_balls).@pl)\n",
+    "agt(suppress(icl>control>do,agt>thing,obj>thing).@present,pass(icl>accomplishment>thing,equ>base_on_balls).@pl)\n",
+    "nam(pass(icl>accomplishment>thing,equ>base_on_balls).@pl,danger(icl>condition>thing,ant>safety).@indef.@double_quote)\n",
+    "man(suppress(icl>control>do,agt>thing,obj>thing).@present,exclude(icl>eliminate>do,src>uw,agt>thing,obj>thing))\n",
+    "mod:01(occasion(icl>happening>thing,equ>juncture),any(icl>adj))\n",
+    "obj:01(exclude(icl>eliminate>do,src>uw,agt>thing,obj>thing),occasion(icl>happening>thing,equ>juncture))\n",
+    "tim(when(icl>how,com>always,tim<uw,obj>uw),when(icl>how,tim<uw,obj>uw))\n",
+    "obj(when(icl>how,com>always,tim<uw,obj>uw),suppress(icl>control>do,agt>thing,obj>thing).@present)\n",
+    "obj:02(use(icl>employ>do,cob>thing,agt>thing,obj>thing,pur>uw):02.@entry.@present,facility(icl>skillfulness>thing,equ>adeptness).@indef.@topic)\n",
+    "mod:03(application(icl>information,equ>request,agt>thing,obj>uw).@indef,immediate(icl>adj,equ>contiguous))\n",
+    "cob:03(cause(icl>occur,cob>uw,obj>uw,ben>thing).@present,application(icl>information,equ>request,agt>thing,obj>uw).@indef)\n",
+    "mod:03(brake(icl>restraint>thing).@def,emergency(icl>crisis>thing))\n",
+    "obj:03(application(icl>information,equ>request,agt>thing,obj>uw).@indef,brake(icl>restraint>thing).@def)\n",
+    "man(signal(icl>signalize>do,agt>person,obj>thing,rec>person).@present,:01)\n",
+    "and(cause(icl>occur,cob>uw,obj>uw,ben>thing).@present,:02)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "Audible and/or visual indication to alert the driver to a condition which requires a positive action by the driver.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "Audible and/or visual indication to alert the driver to a condition which requires a positive action by the driver. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "and(and or,audible(icl>adj,ant>inaudible))\n",
+    "mod(indication(icl>communication>thing).@entry,and or)\n",
+    "obj(and or,visual(icl>adj,equ>ocular,com>sight))\n",
+    "obj(indication(icl>communication>thing).@entry,alert(icl>do,equ>warn,rsn>thing,agt>volitional_thing,obj>person))\n",
+    "obj(alert(icl>do,equ>warn,rsn>thing,agt>volitional_thing,obj>person),driver(icl>operator>thing,ant>nondriver):01.@def)\n",
+    "rsn(alert(icl>do,equ>warn,rsn>thing,agt>volitional_thing,obj>person),condition(icl>state>abstract_thing,aoj>thing).@indef)\n",
+    "cob(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@present,condition(icl>state>abstract_thing,aoj>thing).@indef)\n",
+    "mod(action(icl>abstract_thing,agt>thing).@indef,positive(icl>adj,ant>negative))\n",
+    "obj(require(icl>demand>do,agt>volitional_thing,obj>uw,cag>thing).@present,action(icl>abstract_thing,agt>thing).@indef)\n",
+    "agt(action(icl>abstract_thing,agt>thing).@indef,driver(icl>operator>thing,ant>nondriver):02.@def)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When a traction-driven wheel loses adhesion with the rails.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When a traction-driven wheel loses adhesion with the rails. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "man(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@state,traction(icl>pull>thing))\n",
+    "obj(drive(icl>operate>do,plt>thing,plf>thing,agt>person,obj>vehicle,scn>thing).@state,wheel(icl>machine>thing).@indef)\n",
+    "agt(lose(icl>suffer>do,agt>thing,obj>concrete_thing).@present,wheel(icl>machine>thing).@indef)\n",
+    "obj(when(icl>how,tim<uw,obj>uw).@entry,lose(icl>suffer>do,agt>thing,obj>concrete_thing).@present)\n",
+    "obj(lose(icl>suffer>do,agt>thing,obj>concrete_thing).@present,adhesion(icl>pathology>thing))\n",
+    "obj(adhesion(icl>pathology>thing),rail(icl>barrier>thing,equ>railing).@def.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "When a braked wheel loses adhesion with the rails.\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "[S:00]\n",
+    "{org:en}\n",
+    "When a braked wheel loses adhesion with the rails. \n",
+    "{/org}\n",
+    "{unl}\n",
+    "obj(brake(icl>stop>occur,obj>thing).@state,wheel(icl>machine>thing).@indef)\n",
+    "agt(lose(icl>suffer>do,agt>thing,obj>concrete_thing).@present,wheel(icl>machine>thing).@indef)\n",
+    "obj(when(icl>how,tim<uw,obj>uw).@entry,lose(icl>suffer>do,agt>thing,obj>concrete_thing).@present)\n",
+    "obj(lose(icl>suffer>do,agt>thing,obj>concrete_thing).@present,adhesion(icl>pathology>thing))\n",
+    "obj(adhesion(icl>pathology>thing),rail(icl>barrier>thing,equ>railing).@def.@pl)\n",
+    "{/unl}\n",
+    "[/S]\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "xmldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "unldata = \"\"\"\n",
+    "\n",
+    "\"\"\"\n",
+    "displayUnl(unldata)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/scripts/batch_unlize_directory.sh b/scripts/batch_unlizeXml.sh
similarity index 100%
rename from scripts/batch_unlize_directory.sh
rename to scripts/batch_unlizeXml.sh