% FraGoLi documentation for v. 1.3.4 y. 2026
% 
% Copyright (C) 2026 Paul Eduard Koenig
% pauleduardkoenig (at) gmail [dot] com
% Goethe University Frankfurt, Institute of Linguistics
%
% --------------------------------
%
% O))))))))                    O))))             O))         
% O))                        O)    O))           O))       O)
% O))      O) O)))   O))    O))           O))    O))         
% O))))))   O))    O))  O)) O))         O))  O)) O))      O))
% O))       O))   O))   O)) O))   O))))O))    O))O))      O))
% O))       O))   O))   O))  O))    O)  O))  O)) O))      O))
% O))      O)))     O)) O)))  O)))))      O))    O))))))))O))
% 
% --------------------------------
% 
% This file may be distributed and/or modified under the
% conditions of the LaTeX Project Public License, either
% version 1.3c of this license or (at your option) any later
% version. The latest version of this license is in:
% http://www.latex-project.org/lppl.txt
% and version 1.3c or later is part of all distributions of
% LaTeX version 2008-05-04 or later.
% 
% This work has the LPPL maintenance status `maintained'.
% The Current Maintainer of this work is Paul Eduard Koenig.
% This work consists of the files fragoli.sty and fragoli_doc.tex

\documentclass[10pt, a4paper]{article}
\usepackage[hidelinks]{hyperref}
\usepackage[left=2.5cm, right=2.0cm, top=1cm, bottom=1cm, includeheadfoot]{geometry}
\usepackage{enumerate}
\usepackage{babel}
\usepackage[utf8]{inputenc}
\usepackage[linguistics]{forest}
\usepackage[usetypes=true]{fragoli}
\usepackage{listings}
\usepackage{MnSymbol}
\usepackage{stmaryrd}
\usepackage{showexpl}
\usepackage{expex}

\lstdefinestyle{Common}
{
	language={[LaTeX]TeX},
	numbers=left,
	numbersep=1em,
	numberstyle=\tiny,
	frame=single,
	framesep=\fboxsep,
	framerule=\fboxrule,
	rulecolor=\color{red},
	xleftmargin=\dimexpr\fboxsep+\fboxrule,
	xrightmargin=\dimexpr\fboxsep+\fboxrule,
	breaklines=true,
	breakindent=0pt,
	tabsize=2,
	columns=flexible,
	includerangemarker=false,
	rangeprefix=//\ ,
}
\lstdefinestyle{A}
{
	style=Common,
	numbers=none,
	backgroundcolor=\color{yellow!10},
	basicstyle=\scriptsize\ttfamily,
	keywordstyle=\color{blue}\bf,
	identifierstyle=\color{black},
	stringstyle=\color{red},
	commentstyle=\color{green}
}
\lstdefinestyle{B}
{
	style=Common,
	gobble=5,
	frame=none,
	backgroundcolor=\color{yellow!20},
	basicstyle=\ttfamily,
	keywordstyle=\color{blue}\bf,
	identifierstyle=\color{black},
	stringstyle=\color{red},
	commentstyle=\color{green}
}
\newenvironment{itemizeexample}{
	\begin{itemize}
		\setlength\itemsep{-.5em}
	}
	{
	\end{itemize}
}
\newenvironment{itemizeexamplecommand}{
	\begin{itemize}
		\setlength\itemsep{-0.2em}
	}
	{
	\end{itemize}
}
\newlength{\halb}				\setlength{\halb}{0.5\textwidth}				\addtolength{\halb}{-1mm}


%---------------------------------------------------------------- START --------------------------------------------

\title{\FraGoLi\\Documentation for the \LaTeX\ package \texttt{\her{fragoli}}}
\author{fragoli \textbackslash\text{v} 1.3.4\\Paul Eduard Koenig\\Goethe University Frankfurt,\\Institute of Linguistics\\\texttt{\href{mailto:pauleduardkoenig@gmail.com}{pauleduardkoenig@gmail.com}}}


\begin{document}
	\maketitle
	\begin{abstract}
		\noindent This document provides an overview of the \LaTeX\ package \texttt{fragoli} (Frankfurt Goethe Linguistic). The package is primarily designed for use in the field of semantics, offering a streamlined syntax to facilitate the rapid derivation of semantic formulae. Its notation style is loosely based on the supplementary materials accompanying the introductory course in linguistic semantics by \textit{Thomas Ede Zimmermann}.
	\end{abstract}
	\tableofcontents
	\section{Background}
	This package brings together and refines a collection of \LaTeX\ commands and concepts developed over the years within the institute of linguistics at the Goethe University Frankfurt. In the process of preparing research papers, assignments, and examinations, numerous custom \LaTeX\ headers and commands were shared within the department—some mutually compatible, others not. This package consolidates these resources into a cohesive system. Special thanks are due to \textit{Thomas Ede Zimmermann}, \textit{C\'{e}cile Meier}, \textit{Daniel Gutzmann}, and \textit{Jan Köpping}, whose files form the foundation of this package. Also thanks to \textit{Manuel Lipstein} for his feedback. 
	
	The primary goal of this package is to provide a minimal and user-friendly syntax for constructing large and complex semantic derivations, following the specific notational style used at Goethe University Frankfurt. It includes a comprehensive set of commands for text formatting and various types of bracketing, ensuring a consistent style—particularly when distinguishing between meta-language and object-language within a single derivation or formula.
	
	The semantics-specific commands in this package are organized into three categories: direct interpretation, represented using standard bracketing \sdi{expression}; indirect interpretation, which is further divided into translation \sit{expression} and denotation \sid{expression}. These commands offer extensive customization options and include predefined macros for commonly used constants, lambda expressions, and logical notation in formal semantics and type theory.
	
	Additionally, the package includes specialized commands and environments that extend beyond standard semantic notation. One such feature is the \textit{rb} environment, which implements a rainbow bracketing system inspired by modern programming editors and IDEs. This system assigns matching colors to parentheses at the same depth, with each level of nesting receiving a distinct color. This visual aid significantly enhances the readability of complex derivations and formulae, making them easier to process and debug. However, due to the intricate way \LaTeX\ handles command execution order, this feature currently does not integrate well with commands that generate parentheses as part of their output. While future updates may address this limitation, at present, only manually written parentheses within the \textit{rb} environment are affected by the coloring scheme. Check the \href{https://ctan.org/pkg/rainbowbrackets}{rainbowbrackets} package for additional information and features.
	
	As an example see: \\\verb=\begin{rb}(level1(level2(level3)(level3)))\end{rb}= which results in:  \\\begin{rb}(level1(level2(level3)(level3)))\end{rb}.
	This feature is automatically enabled in some other env. like the \textit{semcalc} framework. To change the colors one needs to manually override the colors \textit{rbbcpcolor0} to \textit{rbbcpcolor9} like this: \\\verb=\definecolor{fglcpcolor0}{RGB}{000, 000, 000}=.
	
	The core component of this package is the \textit{fgls} environment, which provides abbreviated versions of all commands and is designed for constructing larger semantic formulae and derivations. Given the extensive set of custom commands—ranging from one to four letters—potential conflicts with other packages may arise, so careful usage within other environments is advised.
	For example, the minimal syntax facilitated by this environment is illustrated below:
	\begin{lstlisting}[style=B]
			\begin{fgls}[\sone]
				\e{sees} = \ly\lx\n{\Mx sees \My in \cs}
			\end{fgls}
	\end{lstlisting} which renders as: \begin{fgls}[\sone]\ignorespacesafterend\e{sees} = \ly\lx\n{\Mx sees \My in \cs}\end{fgls}.
	The advantage of this syntax lies in its ability to maintain consistent formatting of variables across various levels of nesting. Previously, manually handling the font styles of variables introduced the risk of in\-con\-sis\-ten\-cies—such as losing the correct formatting (e.g., boldface for object-language variables) when copying \LaTeX\ code into new formulae. This issue is eliminated by using commands like \verb=\mx=, which consistently produces an italic, non-bold x for meta-language variables. Additionally, the use of\ \verb=\n{exp...}= ensures structural integrity, as failing to close the expression correctly now results in a compiler error, preventing unintended formatting issues. Also the optional parameter \verb=[\sone]= automatically sets the current situation for all commands inside the local \textit{fgls} env., which makes changes easy.
	
	All of this is designed to make writing large semantic formulae faster and more error prone and to provide beautiful and consistent output.
	\section{Examples}
	To construct a complex semantic derivation, use the \textit{semderivation} environment and introduce each derivation step with the \verb=\ds= command. Within this environment, both the \textit{rb} and \textit{fgls} environments are enabled, allowing for consistent formatting and structured derivations. The \textit{semderivation} environment internally initializes an \textit{itemize} environment, requiring each derivation step to be formatted as an item, which is automatically handled when using the \verb=\ds= command. The first step of any derivation should always use the \verb=\dS= command to omit the initial equal sign for proper formatting.\\
	A local situation can be set within the environment using \\\verb=\begin{semderivation}[situation]derivation...\end{semderivation}=, overriding all default situations in commands that include one. Additionally, a custom reference name can be assigned using \\\verb=\begin{semderivation}[situation][refName]derivation...\end{semderivation}=. \\This reference name allows for automatic referencing of each derivation step, making it possible to cite specific steps within the text. By default, references are numbered sequentially starting from 1. However, a fixed reference name can be specified for consistency across citations.
	
	To reference a specific derivation step, use:
	
	\verb=\ref{sem:deri:refName:ds:dsCount}=
	
	Here, \texttt{refName} refers either to the automatically assigned sequential derivation number or a user-defined reference name, while \texttt{dsCount} denotes the index of the derivation step, beginning at 1.
	
	Example:
	\begin{lstlisting}[style=B]
			\begin{semderivation}[\szero][exampleone]
				\dS{\e{Peter loves Maria}}
				\ds{\e{loves Maria}(\e{Peter})}
				\ds{\e{loves Maria}(Peter)}
				\ds{\e{loves}(\e{Maria})(Peter)}
				\ds{\e{loves}(Maria)(Peter)}
				\ds{\ly\lx\n{\Mx loves \My in \cs}(Maria)(Peter)}
				\ds{\lx\n{\Mx loves Maria in \cs}(Peter)}
				\ds{\n{Peter loves Maria in \cs}}
			\end{semderivation}
	\end{lstlisting} 
	Output: \begin{semderivation}[\szero][exampleone]
		\dS{\e{Peter loves Maria}}
		\ds{\e{loves Maria}(\e{Peter})}
		\ds{\e{loves Maria}(Peter)}
		\ds{\e{loves}(\e{Maria})(Peter)}
		\ds{\e{loves}(Maria)(Peter)}
		\ds{\ly\lx\n{\Mx loves \My in \cs}(Maria)(Peter)}
		\ds{\lx\n{\Mx loves Maria in \cs}(Peter)}
		\ds{\n{Peter loves Maria in \cs}}
	\end{semderivation}
	Note that the default situation has been changed from \sstar to \szero. To ensure consistency within a derivation, it is recommended to specify the desired situation as an environment parameter and reference it within the derivation using the \verb=\cs= command, which represents the current situation. To reference a specific derivation step, use:
	\verb=\ref{sem:deri:exampleone:ds:3}= which will produce: Step \ref{sem:deri:exampleone:ds:3}.
	\\A complete semantic derivation may include not only derivation steps but also trees, rules, and lexical entries. In such cases, use the \textit{semcalc} environment, which is specifically designed for educational purposes. Each \textit{semcalc} environment should follow a standardized structure, though not all components are mandatory:
	\begin{lstlisting}[style=B]
			\begin{semcalc}
				\begin{semtree}
					tree
				\end{semtree}
				\begin{semrule}
					rules...
				\end{semrule}
				\begin{semlex}
					lexicon...
				\end{semlex}
				\begin{semderi}
					derivation...
				\end{semderi}
			\end{semcalc}
	\end{lstlisting}
	All these sub-environments function exclusively within the \textit{semcalc} or \textit{fgls} environments. A detailed ex\-pla\-na\-ti\-on of each sub-environment is provided in the section \ref{sec:semcalc}.
	\\Example for a full semantic calculation for: \sde[\stwo]{Peter sleeps}
	\begin{lstlisting}[style=B]
			\begin{semcalc}[\stwo]
				\begin{semtreesem}
					\\
					\begin{forest}
					[{\e{Peter sleeps}\\S:\typet},name=0
					[{\e{Peter}\\NN:\typee},name=00]
					[{\e{sleeps}\\V:\typeet},name=01]
					]
					\end{forest}
				\end{semtreesem}
				\begin{semlang}
					\rlang{Peter, sleeps}[NN][VP]
				\end{semlang}
				\begin{semrule}
					\rsrdesbjpred
					\rentrysub{\j{Compositional Determination of the Extension of Subject-Predications}\\If \j{S} is a sentence with a predicate \j{P} and a proper name \j{NN} as its subject, then for all \j{s\ \ci\ LR} the above holds.}
				\end{semrule}
				\begin{semlex}
					\sldenn{Peter}
					\sldex{sleeps}
				\end{semlex}
				\begin{semderi}
					\dS{\e{Peter sleeps}}
					\ds[\rr{1}]{\e{sleeps}(\e{Peter})}
					\ds[\rl{1}]{\e{sleeps}(Peter)}
					\ds[\rl{2}]{\lfx{sleeps}(Peter)}
					\ds[\lc]{\n{Peter sleeps in \cs}}
				\end{semderi}
			\end{semcalc}
	\end{lstlisting}
	The code above will result in the following derivation structure:
	\begin{semcalc}[\stwo]
		\begin{semtreesem}
			\\
			\begin{forest}
				[{\e{Peter sleeps}\\S:\typet},name=0
				[{\e{Peter}\\NN:\typee},name=00]
				[{\e{sleeps}\\V:\typeet},name=01]
				]
			\end{forest}
		\end{semtreesem}
		\begin{semlang}
			\rlang{Peter, sleeps}[NN][VP]
		\end{semlang}
		\begin{semrule}[]	
			\rsrdesbjpred
			\rentrysub{\j{Compositional Determination of the Extension of Subject-Predications}\\If \j{S} is a sentence with a predicate \j{P} and a proper name \j{NN} as its subject, then for all \j{s\ \ci\ LR} the above holds.}
		\end{semrule}
		\begin{semlex}
			\sldenn{Peter}
			\sldex{sleeps}
		\end{semlex}
		\begin{semderi}
			\dS{\e{Peter sleeps}}
			\ds[\rr{1}]{\e{sleeps}(\e{Peter})}
			\ds[\rl{1}]{\e{sleeps}(Peter)}
			\ds[\rl{2}]{\lfx{sleeps}(Peter)}
			\ds[\lc]{\n{Peter sleeps in \cs}}
		\end{semderi}
	\end{semcalc}
	As shown on the right, each step references the corresponding rule or lexical entry to indicate to the reader which resource was used to reach the next step. These resources can also be referenced outside of the \textit{semderivation} environment using the command \verb=\ref{sem:deri:refNameresCoderesNumber}=, where \texttt{refName} refers to the derivation reference name (as explained earlier), \texttt{resNumber} is the index of the desired resource (starting from 1), and \texttt{resCode} specifies the kind of resource. There are four types of resource codes: \texttt{r}, \texttt{rs}, \texttt{l}, and \texttt{la}, which stand for resource, resource-syntax, lexicon, and language, respectively. For further details, see Command \ref{command:resourceCounter}.
	\\
	An additional example of a more complex derivation involving indirect interpretation would look like this:
	\begin{lstlisting}[style=B]
			\begin{semderivation}
				\dS{\e[g,\!\cs]{\r[S]{\r[DP]{jeden Esel}\r[S]{\lx\r[S]{Hans \r[VP]{\txs f\"{u}tterte}}}}}}
				\ds[\fa]{\e{jeden Esel}(\e[g,\!\cs]{\lx\r[S]{Hans \r[VP]{\txs f\"{u}tterte}}})}
				\ds[\abs]{\e{jeden Esel}(\lz\e[g{\asmoD{z}[x]},\!\cs]{Hans \r[VP]{\txs f\"{u}tterte}})}
				\ds[\fa]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r[VP]{\txs f\"{u}tterte}}(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
				\ds[\fa]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{f\"{u}tterte}(\e[g{\asmoD{z}[x]},\cs]{\tx})(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
				\ds[SemVar]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{f\"{u}tterte}(\mz)(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
				\ds[\lex]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{f\"{u}tterte}(\mz)(Hans)})}
				\ds[\lex]{\e{jeden Esel}(\lz\r{\ly\lx\n{\mx\ f\"{u}tterte \my\ in \cs}(\mz)(Hans)})}
				\ds[\lc]{\e{jeden Esel}(\lz\r{\lx\n{\mx\ f\"{u}tterte \mz\ in \cs}(Hans)})}
				\ds[\lc]{\e{jeden Esel}(\lz\n{Hans f\"{u}tterte \mz\ in \cs})}
				\ds[\lex]{\lX\n{\sa\e{Esel}\Cq\sa\mX}(\lz\n{Hans f\"{u}tterte \mz\ in \cs})}
				\ds[\lc]{\n{\sa\e{Esel}\Cq\sA{\lz\n{Hans f\"{u}tterte \mz\ in \cs}}}}
				\ds[\lex]{\n{\sA{\lx\n{\mx\ ist ein Esel in \cs}}\Cq\sA{\lz\n{Hans f\"{u}tterte \mz\ in \cs}}}}
				\ds[Def. \cd]{\n{\s{\Sv ist ein Esel in \cs}\Cq\s{Hans f\"{u}tterte \Sv in \cs}}}
				\ds[\nc]{\n{\cset{Esel}\Cq\s{Hans f\"{u}tterte \Sv in \cs}}}
				\ds{1 gdw. alle Individuen, die Esel sind in \cs\ auch Individuen sind, die von Hans in \cs\ gef\"{u}ttert werden, sonst 0.}
			\end{semderivation}
	\end{lstlisting}
	which would result in a derivation that looks like this (derivation for \textit{Hans fed every donkey} with quantifier raising):
	\begin{semderivation}
		\dS{\e[g,\!\cs]{\r[S]{\r[DP]{jeden Esel}\r[S]{\lx\r[S]{Hans \r[VP]{\txs fütterte}}}}}}
		\ds[\fa]{\e{jeden Esel}(\e[g,\!\cs]{\lx\r[S]{Hans \r[VP]{\txs fütterte}}})}
		\ds[\abs]{\e{jeden Esel}(\lz\e[g{\asmoD{z}[x]},\!\cs]{Hans \r[VP]{\txs fütterte}})}
		\ds[\fa]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{\r[VP]{\txs fütterte}}(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
		\ds[\fa]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{fütterte}(\e[g{\asmoD{z}[x]},\cs]{\tx})(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
		\ds[SemVar]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{fütterte}(\mz)(\e[g{\asmoD{z}[x]},\!\cs]{Hans})})}
		\ds[\lex]{\e{jeden Esel}(\lz\r{\e[g{\asmoD{z}[x]},\!\cs]{fütterte}(\mz)(Hans)})}
		\ds[\lex]{\e{jeden Esel}(\lz\r{\ly\lx\n{\mx\ fütterte \my\ in \cs}(\mz)(Hans)})}
		\ds[\lc]{\e{jeden Esel}(\lz\r{\lx\n{\mx\ fütterte \mz\ in \cs}(Hans)})}
		\ds[\lc]{\e{jeden Esel}(\lz\n{Hans fütterte \mz\ in \cs})}
		\ds[\lex]{\lX\n{\sa\e{Esel}\Cq \sa\mX}(\lz\n{Hans fütterte \mz\ in \cs})}
		\ds[\lc]{\n{\sa\e{Esel}\Cq \sA{\lz\n{Hans fütterte \mz\ in \cs}}}}
		\ds[\lex]{\n{\sA{\lx\n{\mx\ ist ein Esel in \cs}}\Cq\sA{\lz\n{Hans fütterte \mz\ in \cs}}}}
		\ds[Def. \cd]{\n{\s{\Sv ist ein Esel in \cs}\Cq\s{Hans fütterte \Sv in \cs}}}
		\ds[\nc]{\n{\cset{Esel}\Cq\s{Hans fütterte \Sv in \cs}}}
		\ds{1 gdw. alle Individuen, die Esel sind in \cs\ auch Individuen sind, die von Hans in \cs\ gefüttert werden, sonst 0.}
	\end{semderivation}
	Note that the comments on the right should signal the reader which rule or lexical entry or notational convention has been used to get to the next step.
	
	If you want to use all the shortcuts provided by the \textit{fgls} environment for a formulae that's rather short or inside a bigger text, use the \textit{fglsem} wrapper command like \verb=\fglsem{\t{Expression}}= which will result in \fglsem{\t{Expression}} without any automatic line breaks or indentation. 
	\section{Usage}
	To use the \texttt{\her{fragoli}} package place the \her{fragoli.sty} file in the same folder as your document and include:
	\begin{lstlisting}[style=A]
			\usepackage{fragoli}
	\end{lstlisting}
	\subsection{Package Options}
	To combine multiple package options use \her{, } like:
	\begin{lstlisting}[style=A]
			\usepackage[userainbow=true, language=german]{fragoli}
	\end{lstlisting}
	\subsubsection{language}
	\begin{lstlisting}[style=A]
			\usepackage[language=LANGUAGE]{fragoli}
	\end{lstlisting}
	This option will effect the default lexicon and rule entries as well as the labels for a semantic derivation. The default is set to \texttt{\her{english}}, valid options are:
	\begin{itemizeexample}
		\item[-] english (e.g. R1: \sit{Every-} = \lambH{Q}(\lambH{P}\lambheN\lambbY{\sand{\obli{Q}(\obli{x})}{\obli{P}(\obli{x})}}))
		\item[-] german (e.g. R1: \sit{Jed-} = \lambH{Q}(\lambH{P}\lambheN\lambbY{\sand{\obli{Q}(\obli{x})}{\obli{P}(\obli{x})}}))
	\end{itemizeexample}
	\subsubsection{userainbow}
	\begin{lstlisting}[style=A]
			\usepackage[userainbow=BOOL]{fragoli}
	\end{lstlisting}
	This option will effect the automatic coloring of parentheses levels within a semantic derivation or the \textit{rb} environment. The default is set to \texttt{\her{true}}, valid options are true/false. To change the colors one needs to manually override the color values \textit{fglcpcolor0} to \textit{fglcpcolor5} like this: \\\verb=\definecolor{fglcpcolor0}{RGB}{000, 000, 000}=.
	\begin{itemizeexample}
		\item[-] true (e.g. \begin{rb}(level0(level1((level3(level4(level5(level6))))level2)))\end{rb})
		\item[-] false (e.g. (level0(level1((level3(level4(level5(level6))))level2))))
	\end{itemizeexample}
	\subsubsection{semanticbracketdirectstyle}
	\begin{lstlisting}[style=A]
			\usepackage[semanticbracketdirectstyle=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default bracketing style of all commands related to direct interpretation (e.g. \verb=\sde{expression}=). The default is set to \texttt{\her{textcomp}}, valid options are:
	\begin{itemizeexample}
		\item[-] \texttt{\href{https://www.ctan.org/pkg/textcomp}{textcomp}} (e.g. \fglsetdirectdelimitertextcomp\sde{expression}/\sdE{expression}\fglresetdirectdelimiter)
		\item[-] \texttt{\href{https://www.ctan.org/pkg/stmaryrd}{stmaryrd}} (e.g. \fglsetdirectdelimiterstmaryrd\sde{expression}/\sdE{expression}\fglresetdirectdelimiter)
		\item[-] \texttt{\href{https://www.ctan.org/pkg/mathabx}{mathabx}} (can't be displayed here)
		\item[-] \texttt{\href{https://www.ctan.org/pkg/mnsymbol}{MnSymbol}} (e.g. \fglsetdirectdelimitermnsymbol\sde{expression}/\sdE{expression}\fglresetdirectdelimiter)
		\item[-] \texttt{mixed} (e.g. \fglsetdirectdelimitermixed\sde{expression}/\sdE{expression}\fglresetdirectdelimiter)
	\end{itemizeexample}
	\textit{textcomp} is recommended as it is the only font/package that supports a bold option nativly (the others need \verb=\bm= or \verb=\pmb=) and it is best at scaling. It is also part of the official \LaTeX\ distribution since 2020 which reduces possible conflicts with other packages and general load time. The \texttt{mixed} option uses the stmaryrd brackets for normal mode and the textcomp brackets for bold mode.
	To change/reset the style mid document use (for these commands to function as intended the required package needs to be included manually first--if the package option is different):
	\begin{lstlisting}[style=A]
			\fglsetdirectdelimitertextcomp
			\fglsetdirectdelimiterstmaryrd
			\fglsetdirectdelimitermathabx
			\fglsetdirectdelimitermnsymbol
	\end{lstlisting}
	\noindent To reset the delimiters to the package default:
	\begin{lstlisting}[style=A]
			\fglresetdirectdelimiter
	\end{lstlisting}
	To set each delimiter manually to a custom symbol use: 
	\begin{lstlisting}[style=A]
			\fglsetdirectdelimiterl{symbol}
			\fglsetdirectdelimiterr{symbol}
			\fglsetdirectdelimiterL{symbol}
			\fglsetdirectdelimiterR{symbol}
	\end{lstlisting}
	To reset each delimiter manually to the package default use: 
	\begin{lstlisting}[style=A]
			\fglresetdirectdelimiterl
			\fglresetdirectdelimiterr
			\fglresetdirectdelimiterL
			\fglresetdirectdelimiterR
	\end{lstlisting}
	\subsubsection{usetypes}
	\begin{lstlisting}[style=A]
			\usepackage[usetypes=BOOL]{fragoli}
	\end{lstlisting}
	This option will effect if the default types in lexicon and rule entries are displayed. The default is set to \texttt{\her{false}}, valid options are true/false.
	\begin{itemizeexample}
		\item[-] true (e.g. R1: \sit{Every-} =  \lambH{Q}[\type{et}](\lambH{P}[\type{et}]\lambhen[x][\type{e}]\lambbY{\sand{\obli{Q}(\obli{x})}{\obli{P}(\obli{x})}}))
		\item[-] false (e.g. R1: \sit{Every-} =  \lambH{Q}(\lambH{P}$\neg$($\exists$$x$)\lambbY{\sand{\obli{Q}(\obli{x})}{\obli{P}(\obli{x})}}))
	\end{itemizeexample}
	\subsubsection{typestyle}
	\begin{lstlisting}[style=A]
			\usepackage[typestyle=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default parentheses style of all types added with the \verb=\type{#1}= command. The default is set to \texttt{\her{normal}}, valid options are:
	\begin{itemizeexample}
		\item[-] normal (e.g. \type{et})
		\item[-] classic (e.g. \type{et}[(][)])
		\item[-] alternative (e.g. \type{et}[$<$][$>$])
	\end{itemizeexample}
	To change/reset the type style mid document to a custom symbol use:
	\begin{lstlisting}[style=A]
			\fglsetparleft{symbol}
			\fglsetparright{symbol}
			\fglresetparleft
			\fglresetparright
	\end{lstlisting}
	\subsubsection{typesspacing}
	\begin{lstlisting}[style=A]
			\usepackage[typespacing=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default parentheses spacing of all types added with the \verb=\type{#1}= command. The default is set to \texttt{\her{mid}}, valid options are:
	\begin{itemizeexample}
		\item[-] narrow (e.g. \type{e\t{et}})\hfill negthinspace and kern-1pt
		\item[-] mid (e.g. \type[\!][]{e\t{et}})\hfill negthinspace and default space
		\item[-] wide (e.g. $\langle$$e$$\langle$$et$$\rangle$$\rangle$)\hfill default space
	\end{itemizeexample}
	To change/reset the spacing (any custom value possible) mid document use:
	\begin{lstlisting}[style=A]
			\fglsettypespaceinner{spacing}
			\fglsettypespaceouter{spacing}
			\fglresettypespaceinner
			\fglresettypespaceouter
	\end{lstlisting}
	\subsubsection{typenestingstyle}
	\begin{lstlisting}[style=A]
			\usepackage[typenestingstyle=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default parentheses nesting style of all types added with the \verb=\type{#1}= command. The default is set to \texttt{\her{normal}}, valid options are:
	\begin{itemizeexample}
		\item[-] normal (e.g. \type{e\t{et}}, here the first level also has parentheses)
		\item[-] classic (e.g. \type{e\t{et}[\langle][\rangle]}[][], here only the nested levels have parentheses)
	\end{itemizeexample}
	\subsubsection{lambdaheadstyle}
	\begin{lstlisting}[style=A]
			\usepackage[lambdaheadstyle=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default type positioning/style of all lambda heads when adding a type as argument. The default is set to \texttt{\her{normal}}, valid options are:
	\begin{itemizeexample}
		\item[-] normal (e.g. $\lambda$\meli{Q}\textsubscript{\type{et}}\!.)
		\item[-] domain (e.g. $\lambda$\meli{Q} $\in$ D\textsubscript{\type{et}}\!.)
		\item[-] upper (e.g. $\lambda$\meli{Q}\textsuperscript{\type{et}}\!.)
	\end{itemizeexample}
	\subsubsection{lambdaheadspacing}
	\begin{lstlisting}[style=A]
			\usepackage[lambdaheadspacing=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default spacing of all lambda heads (effecting the dot and the optional types). The default is set to \texttt{\her{narrow}}, valid options are:
	\begin{itemizeexample}
		\item[-] narrow (e.g. \lambh{x}[\typee]\lambh{y}[\typee])\hfill negthinspace
		\item[-] mid (e.g. \lambh{x}[\typee][\kern-1pt]\lambh{y}[\typee][\kern-1pt])\hfill kern-1pt
		\item[-] wide (e.g. \lambh{x}[\typee][]\lambh{y}[\typee][])\hfill default space
	\end{itemizeexample}
	To change/reset the spacing (any custom value possible) mid document use:
	\begin{lstlisting}[style=A]
			\fglsetlambdaheadspacing{spacing}
			\fglresetlambdaheadspacing
	\end{lstlisting}
	\subsubsection{usedscount}
	\begin{lstlisting}[style=A]
			\usepackage[usedscount=BOOL]{fragoli}
	\end{lstlisting}
	This option will effect if the row count will be displayed in every semantic derivation step in the \textit{semderivation} and \textit{semderi} environments. The default is set to \texttt{\her{true}}, valid options are true/false. To change the color one needs to manually override the color value like this: \\\verb=\definecolor{fgldeivationrowcountcolor}{RGB}{000, 000, 000}=.
	\begin{center}
		\begin{minipage}[h][2cm][t]{15em}
			true:\begin{itemizeexample}
				\item[] \lambh{x}\lambbY{$x$+2}(2)
				\item[$\stackrel{\color{fgldeivationrowcountcolor}2.\color{black}}{=}$] 2+2
				\item[$\stackrel{\color{fgldeivationrowcountcolor}3.\color{black}}{=}$] 4
			\end{itemizeexample}
		\end{minipage}
		\begin{minipage}[h][2cm][t]{15em}
			false:\begin{itemizeexample}
				\item[] \lambh{x}\lambbY{$x$+2}(2)
				\item[=] 2+2
				\item[=] 4
			\end{itemizeexample}
		\end{minipage}
	\end{center}
	\subsubsection{rulesituation}
	\begin{lstlisting}[style=A]
			\usepackage[rulesituation=SITUATION]{fragoli}
	\end{lstlisting}
	This option will effect every predefined semantic rule resource (NOT the lexical entries or the default situation within the fgls env.). By default the situation displayed will be $s$. Note that every predefined rule can be customized individually again.
	\subsubsection{situation}
	\begin{lstlisting}[style=A]
			\usepackage[situation=SITUATION]{fragoli}
	\end{lstlisting}
	This option will effect every predefined situation (EXCEPT for all the predefined rules). By default the situation displayed will be \sstar. Note that every predefined situation can be customized individually again. This will effect for example every command that contains a situation and also every shortcut in the \textit{fgls} environment, also every predefined lexical entry and all other occurrences of situations.
	\subsubsection{situationspacing}
	\begin{lstlisting}[style=A]
			\usepackage[situationspacing=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default spacing of all situations. The default is set to \texttt{\her{narrow}}, valid options are:
	\begin{itemizeexample}
		\item[-] narrow (e.g. \sobj{s}{1}[\kern-0.8pt])\hfill kern-0.8pt
		\item[-] mid (e.g. \sobj{s}{1}[\kern-0.3pt])\hfill kern-0.3pt
		\item[-] wide (e.g. \sobj{s}{1}[])\hfill default space
	\end{itemizeexample}
	To change/reset the spacing (any custom value possible) mid document use:
	\begin{lstlisting}[style=A]
			\fglsetsituationspacing{spacing}
			\fglresetsituationspacing
	\end{lstlisting}
	\subsubsection{tracespacing}
	\begin{lstlisting}[style=A]
			\usepackage[tracespacing=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default spacing of all traces. The default is set to \texttt{\her{mid}}, valid options are:
	\begin{itemizeexample}
		\item[-] narrow (e.g. \sobj{t}{x}[\kern-0.8pt])\hfill kern-0.8pt
		\item[-] mid (e.g. \sobj{t}{x}[\kern-0.3pt])\hfill kern-0.3pt
		\item[-] wide (e.g. \sobj{t}{x}[])\hfill default space
	\end{itemizeexample}
	To change/reset the spacing (any custom value possible) mid document use:
	\begin{lstlisting}[style=A]
			\fglsettracespacing{spacing}
			\fglresettracespacing
	\end{lstlisting}
	\subsubsection{semanticsuperscriptspacing}
	\begin{lstlisting}[style=A]
			\usepackage[semanticsuperscriptspacing=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default spacing superscripts for direct and indirect bracketing. The default is set to \texttt{\her{narrow}}, valid options are:
	\begin{itemizeexample}
		\item[-] narrow (e.g. \sde{Peter})\hfill negthinspace
		\item[-] mid (e.g. \sde[\sstar][\kern-1pt]{Peter})\hfill kern-1pt
		\item[-] wide (e.g. \sde[\sstar][]{Peter})\hfill default space
	\end{itemizeexample}
	To change/reset the spacing (any custom value possible) mid document use:
	\begin{lstlisting}[style=A]
			\fglsetsuperscriptspacing{spacing}
			\fglresetsuperscriptspacing
	\end{lstlisting}
	\subsubsection{assignmentspacing}
	\begin{lstlisting}[style=A]
			\usepackage[assignmentspacing=STYLE]{fragoli}
	\end{lstlisting}
	This option will effect the default spacing of all assignment functions. The default is set to \texttt{\her{mid}}, valid options are:
	\begin{itemizeexample}
		\item[-] narrow (e.g. \sidr{Peter}{r}[x][g])\hfill negthinspace
		\item[-] mid (e.g. \sidr{Peter}{r}[x][g][\kern-1pt])\hfill kern-1pt
		\item[-] wide (e.g. \sidr{Peter}{r}[x][g][])\hfill default space
	\end{itemizeexample}
	To change/reset the spacing (any custom value possible) mid document use:
	\begin{lstlisting}[style=A]
			\fglsetassignmentspacing{spacing}
			\fglresetassignmentspacing
	\end{lstlisting}
	\subsubsection{alternativecommands}
	\begin{lstlisting}[style=A]
			\usepackage[alternativecommands=BOOL]{fragoli}
	\end{lstlisting}
	This option enables a set of alternative commands for backwards compatibility within the institute. This is only needed to support legacy code (e.g. Typ, Bsp, Tran, char, WW etc.), debug, and for institute internal usage.
	\section{Commands}
	Most commands in this package have two versions, one normal and one bold version. For the bold version just write the last letter in uppercase (except for a few commands).
	\subsection{Text}
	This section lists commands modifying the appearance of text.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\oo{text}[height]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to overline
					\item[] \texttt{height}(def=-2ex): Set the overlining height
				\end{itemizeexamplecommand}
				\item[] Description: Double overlining (that works with line breaks)
				\item[] Example: \oo{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\oO{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to overline
				\end{itemizeexamplecommand}
				\item[] Description: Double over lining (that works with line breaks) with more space (-2.5ex)
				\item[] Example: \oO{Test}}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Object Language}
	Marks text as object language in opposition to meta language.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\obl{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to format
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as object language
				\item[] Example: \obl{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\obli{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to format
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as object language italic
				\item[] Example: \obli{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\obla{arg}[arg2][arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: First argument
					\item[] \texttt{argN}: nth argument
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as object language arguments with up to 8 optional arguments in normal parentheses behind the first argument
				\item[] Example: \obla{arg}[optional1][optional2]}...
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\oblia{arg}[arg2][arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: First argument
					\item[] \texttt{argN}: nth argument
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as object language italic arguments with up to 8 optional arguments in normal parentheses behind the first argument
				\item[] Example: \oblia{arg}[optional1][optional2]}...
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Meta Language}
	Marks text as meta language in opposition to object language. Used to ensure text is not formatted in a chain of commands.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\mel{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to format
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as meta language
				\item[] Example: \mel{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\meli{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text to format
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as meta language italic
				\item[] Example: \meli{Test}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\mela{arg}[arg2][arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: First argument
					\item[] \texttt{argN}: nth argument
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as meta language arguments with up to 8 optional arguments in normal parentheses behind the first argument
				\item[] Bold Option: Yes
				\item[] Example: \mela{arg}[optional1][optional2]}...
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\melia{arg}[arg2][arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: First argument
					\item[] \texttt{argN}: nth argument
				\end{itemizeexamplecommand}
				\item[] Description: Marking text as meta language italic arguments with up to 8 optional arguments in normal parentheses behind the first argument
				\item[] Bold Option: Yes
				\item[] Example: \melia{arg}[optional1][optional2]}...
		\end{itemizeexamplecommand}
	\xe
	\subsection{Bracketing}
	This section lists general text bracketing commands.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\set[var]{properties}[name]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}(def=x): Variable name and/or domain specifier
					\item[] \texttt{properties}: Set-builder notation
					\item[] \texttt{var}(def=): The name of the set
				\end{itemizeexamplecommand}
				\item[] Description: Creating an inensional build set. Each use of this command will override the \verb=\setvar= command. This command should be used inside the set properties to reference the set variable. The reference will always cut the content of the optional \textit{var} argument before the first space character. Use \verb=\Setvar= to automatically add a space behind the command. To change the style of the set from : to e.g. $|$ replace the \verb=\@fglsetspacer= constant using \verb=\newcommand{\@fglsetspacer}{$|$}=.
				\item[] Bold Option: Yes
				\item[] Example: \verb=\set[n \in \mathbb{N}]{\Setvar is even}[A]= will result in: \set[n \in \mathbb{N}]{\Setvar is even}[A]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\bool{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text inside truth brackets
				\end{itemizeexamplecommand}
				\item[] Description: Creating truth conditional bracketing.
				\item[] Bold Option: Yes
				\item[] Example: \bool{it rains in \sstar}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambby[subInner][subOuter]{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{subInner}: Optional subscript behind opening bracket. Text will be in mathmode. (mostly used in tree like structures)
					\item[] \texttt{subOuter}: Optional subscript behind closing bracket. Text will be in mathmode (mostly used to identify types)
					\item[] \texttt{text}: Text inside rectangle brackets 
				\end{itemizeexamplecommand}
				\item[] Description: Creating rectangle brackets, mainly used for a lambda function body.
				\item[] Bold Option: Yes
				\item[] Example: \lambbY{P $\land$ Q}
				\item[] Example: \lambbY[Inner][Outer]{P $\land$ Q}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\zit{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text inside double quotation marks
				\end{itemizeexamplecommand}
				\item[] Description: Creating double quotation marks around passed text.
				\item[] Bold Option: Yes
				\item[] Example: \zit{Autounfall}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\her{text}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}: Text inside single quotation marks
				\end{itemizeexamplecommand}
				\item[] Description: Creating single quotation marks around passed text.
				\item[] Bold Option: Yes
				\item[] Example: \her{Autounfall}}
		\end{itemizeexamplecommand}
	\xe
	\subsection{Logic}
	This section covers commands for logic symbols modified for semantic purposes.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sneg
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a negation symbol.
				\item[] Bold Option: Yes
				\item[] Example: \sneg}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\strue
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a verum symbol.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \strue}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sfalse
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a falsum symbol.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \sfalse}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\snec
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a necessity symbol.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \snec}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sposs
			\end{lstlisting}
			{\scriptsize
				\item[] Description: Creating a possible symbol.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \sposs}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\simp{arg1}{arg2}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: Antecedent.
					\item[] \texttt{arg2}: Consequent.
				\end{itemizeexamplecommand}
				\item[] Description: Creating a material implication.
				\item[] Bold Option: Yes
				\item[] Example: \simp{a}{b}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\simpnc{arg1}{arg2}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: Antecedent.
					\item[] \texttt{arg2}: Consequent.
				\end{itemizeexamplecommand}
				\item[] Description: Creating a material implication but without the notational convention.
				\item[] Bold Option: Yes
				\item[] Example: \simpnc{a}{b}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sor{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st disjunct
					\item[] \texttt{arg2}: 2nd disjunct
					\item[] \texttt{argN}: nth disjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a disjunctive formula with min. 2 disjuncts.
				\item[] Bold Option: Yes
				\item[] Example: \sor{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sornc{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st disjunct
					\item[] \texttt{arg2}: 2nd disjunct
					\item[] \texttt{argN}: nth disjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a disjunctive formula with min. 2 disjuncts but without the notational convention.
				\item[] Bold Option: Yes
				\item[] Example: \sornc{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sxor{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st disjunct
					\item[] \texttt{arg2}: 2nd disjunct
					\item[] \texttt{argN}: nth disjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating an exclusive disjunctive formula with min. 2 disjuncts.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \sxor{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sxornc{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st disjunct
					\item[] \texttt{arg2}: 2nd disjunct
					\item[] \texttt{argN}: nth disjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating an exclusive disjunctive formula with min. 2 disjuncts but without the notational convention.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \sxornc{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sand{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st conjunct
					\item[] \texttt{arg2}: 2nd conjunct
					\item[] \texttt{argN}: nth conjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a conjunctive formula with min. 2 conjuncts.
				\item[] Bold Option: Yes
				\item[] Example: \sand{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sandnc{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8][arg9]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: 1st conjunct
					\item[] \texttt{arg2}: 2nd conjunct
					\item[] \texttt{argN}: nth conjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a conjunctive formula with min. 2 conjuncts but without the notational convention.
				\item[] Bold Option: Yes
				\item[] Example: \sandnc{a}{b}[c]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\slogic{symbol}{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{symbol}: the junctor symbol (math mode is enforced)
					\item[] \texttt{arg1}: 1st conjunct
					\item[] \texttt{arg2}: 2nd conjunct
					\item[] \texttt{argN}: nth conjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a blank formula with min. 2 arguments.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \verb=\slogic{\oplus}{a}{b}= will result in: \slogic{\oplus}{a}{b}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\slogicnc{symbol}{arg1}{arg2}[arg3][arg4][arg5][arg6][arg7][arg8]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{symbol}: the junctor symbol (math mode is enforced)
					\item[] \texttt{arg1}: 1st conjunct
					\item[] \texttt{arg2}: 2nd conjunct
					\item[] \texttt{argN}: nth conjunct
				\end{itemizeexamplecommand}
				\item[] Description: Creating a blank formula with min. 2 arguments but without the general notational convention.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \verb=\slogicnc{\oplus}{a}{b}}= will result in:  \slogicnc{\oplus}{a}{b}}
		\end{itemizeexamplecommand}
	\xe
	\subsection{Lambda}
	This section covers commands for creating lambda functions.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfx{body}[headVar][headType]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar(def=x)}: lambda head variable
					\item[] \texttt{headType}: head variable type
				\end{itemizeexamplecommand}
				\item[] Description: Creates a full lambda function with changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfx{\textit{x} sleeps in \sstar}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfyx{body}[headVar1][headVar2][headType1][headType2]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar1(def=y)}: first lambda head variable
					\item[] \texttt{headVar2(def=x)}: second lambda head variable
					\item[] \texttt{headType1}: first head variable type
					\item[] \texttt{headType2}: second head variable type
				\end{itemizeexamplecommand}
				\item[] Description: Creates a full lambda function with two changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfyx{\textit{x} kills \textit{y} in \sstar}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfzyx{body}[headVar1][headVar2][headVar3][headType1][headType2][headType3]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar1(def=z)}: first lambda head variable
					\item[] \texttt{headVar2(def=y)}: second lambda head variable
					\item[] \texttt{headVar3(def=x)}: third lambda head variable
					\item[] \texttt{headType1}: first head variable type
					\item[] \texttt{headType2}: second head variable type
					\item[] \texttt{headType3}: third head variable type
				\end{itemizeexamplecommand}
				\item[] Description: Creates a full lambda function with three changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfzyx{\textit{x} gives \textit{y} \textit{z} in \sstar}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfsx{body}[headVar][situationVar][headType][situationType]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar(def=x)}: lambda head variable
					\item[] \texttt{situationVar(def=s)}: lambda head variable for the situation
					\item[] \texttt{headType}: head variable type
					\item[] \texttt{situationType}: situation type (should be used if you want to display the type)
				\end{itemizeexamplecommand}
				\item[] Description: Creates a full lambda function with changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfsx{\textit{x} sleeps in \sblank}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfsyx{body}[headVar1][headVar2][situationVar][headType1][headType2][situationType]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar1(def=y)}: first lambda head variable
					\item[] \texttt{headVar2(def=x)}: second lambda head variable
					\item[] \texttt{situationVar(def=s)}: lambda head variable for the situation
					\item[] \texttt{headType1}: first head variable type
					\item[] \texttt{headType2}: second head variable type
					\item[] \texttt{situationType}: situation type (should be used if you want to display the type)
				\end{itemizeexamplecommand}
				\item[] Description: Creates a full lambda function with two changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfsyx{\textit{x} kills \textit{y} in \sblank}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambfszyx{body}[headVar1][headVar2][headVar3][situationVar][headType1][headType2][headType3][situationType]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{body}: lambda function body
					\item[] \texttt{headVar1(def=z)}: first lambda head variable
					\item[] \texttt{headVar2(def=y)}: second lambda head variable
					\item[] \texttt{headVar3(def=x)}: third lambda head variable
					\item[] \texttt{situationVar(def=s)}: lambda head variable for the situation
					\item[] \texttt{headType1}: first head variable type
					\item[] \texttt{headType2}: second head variable type
					\item[] \texttt{headType3}: third head variable type
					\item[] \texttt{situationType}: situation type (should be used if you want to display the type)
				\end{itemizeexamplecommand}
				\item[] Description: Creates a full lambda function with three changeable head variable and optional head type.
				\item[] Bold Option: Yes
				\item[] Example: \lambfszyx{\textit{x} gives \textit{y} \textit{z} in \sblank}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambh{var}[type][spacing]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: head argument
					\item[] \texttt{type}: argument type
					\item[] \texttt{spacing(def=negthinspace)}: spacing between dots and optional type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambh{x}[\type{e}]
				\item[] Example: \lambH{x}[\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhe[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating an existential head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambhe[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhen[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a negated existential head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambhen[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhu[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a uniqueness head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \lambhu[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhun[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a negated uniqueness head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Since: 1.1.1
				\item[] Example: \lambhun[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambha[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a universal head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambha[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\lambhan[var][type]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{var}: head argument
					\item[] \texttt{type}: argument type
				\end{itemizeexamplecommand}
				\item[] Description: Creating a negated universal head for an anonymous function with an optional type.
				\item[] Bold Option: Yes
				\item[] Example: \lambhan[x][\type{e}]}
		\end{itemizeexamplecommand}
	\xe
	
	\subsection{Semantics}
	General semantics commands.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\type[innerSpacing][outerSpacing]{type}[leftPar][rightPar]
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{innerSpacing(def=negthinspace)}: spacing between type text and the left and right parentheses
					\item[] \texttt{outerSpacing(def=-1pt)}: spacing between the parentheses
					\item[] \texttt{type}: the type (e.g. et)
					\item[] \texttt{leftPar(def=$\langle$)}: left parentheses
					\item[] \texttt{rightPar(def=$\rangle$)}: right parentheses
				\end{itemizeexamplecommand}
				\item[] Description: Creating a type. Should max consist of two letters or nested type functions. Within the command, the abreviated command \verb=\t{type}= can be used instead of \verb=\type{type}= which will shorten the nested code. Also some of the most common types have special shortcuts, see Section \ref{ex:typeshortcuts} for a full list.
				\item[] Bold Option: No
				\item[] Example: \verb=\type{e\t{et}}= = \type{e\t{et}} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sarg{index}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{index}: the situation index
				\end{itemizeexamplecommand}
				\item[] Description: Creating a situation variable with an index.
				\item[] Bold Option: Yes (uppercase r results in superscript indexing)
				\item[] Example: \sarg{5} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\trace{variable}[traceSymbol][spacing]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{variable}: the variable for which the trace is for
					\item[] \texttt{traceSymbol (def=\textit{t})}: the trace symbol
					\item[] \texttt{spacing (def=kern-0.3pt)}: the spacing of the subscript
				\end{itemizeexamplecommand}
				\item[] Description: Creates a trace with a given variable.
				\item[] Bold Option: Yes 
				\item[] Example: \trace{x}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sarrow{function}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{variable}: the characteristic function.
				\end{itemizeexamplecommand}
				\item[] Description: Creates a downarrow and puts the function behind it without space.
				\item[] Bold Option: Yes (will put everything behind arrow in square brackets)
				\item[] Example: \sarrow{\sde{sleeps}}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\cset{function}[argument][situation]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{variable}: the characteristic set.
					\item[] \texttt{argument(def=)}: optional specifier argument.
					\item[] \texttt{situation(def=\sstar)}: the situation argument.
				\end{itemizeexamplecommand}
				\item[] Description: Creates a set.
				\item[] Bold Option: No
				\item[] Example: \verb=\cset{Kills}[Peter]= will create the set of every person that got killed by Peter in the situation \sstar, which will look like this: \cset{Kills}[Peter]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\func[name]{domain1}{range1}[domain2][range2][domain3][range3][domain4][range4]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: the optional function name.
					\item[] \texttt{domain1}: the first domain.
					\item[] \texttt{range1}: the first range.
					\item[] \texttt{domain2}: the optional second domain.
					\item[] \texttt{range2}: the optional second range.
					\item[] \texttt{domain3}: the optional third domain.
					\item[] \texttt{range3}: the optional third range.
					\item[] \texttt{domain4}: the optional fourth domain.
					\item[] \texttt{range4}: the optional fourth range.
				\end{itemizeexamplecommand}
				\item[] Description: Creates a function in array notation. This command can be nested. It is a \her{quick and dirty} version of the \textit{fglfunc} environment and should only be used for small functions or inside text. Problems regarding vertical spacing can arise when creating bigger functions via nesting, in that case use Environment \ref{env:fglfunc} and change the spacing parameter.
				\item[] Since: 1.1.1
				\item[] Example: \verb=\func[A]{\szero}{B}[\sone][C][\stwo][D]= will create: \func[A]{\szero}{B}[\sone][C][\stwo][D]
				\item[] Example: \verb=\func[B]{a}{1}[b][1][c][\func{x}{1}[y][2][x][3]]= will create: \func[B]{a}{1}[b][1][c][\func{x}{1}[y][2][x][3]]}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Direct Interpretation}
	This section covers commands for direct semantic interpretation.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sdi{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to interpret.
				\end{itemizeexamplecommand}
				\item[] Description: Creating double square bracketing for an object language expression without a situation argument.
				\item[] Bold Option: Yes
				\item[] Example: \sdi{sleeps} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sdim{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to interpret.
				\end{itemizeexamplecommand}
				\item[] Description: Creating double square bracketing for a meta language expression without a situation argument.
				\item[] Bold Option: Yes
				\item[] Example: \sdim{sleeps} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sde[situation][spacing]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: the situation argument.
					\item[] \texttt{spacing(def=negthinspace)}: the spacing of the superscript to the brackets.
					\item[] \texttt{expression}: the expression to interpret.
				\end{itemizeexamplecommand}
				\item[] Description: Creating double square bracketing for an object language expression with a situation argument.
				\item[] Bold Option: Yes
				\item[] Example: \sde{sleeps} }
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sdem[situation][spacing]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: the situation argument.
					\item[] \texttt{spacing(def=negthinspace)}: the spacing of the superscript to the brackets.
					\item[] \texttt{expression}: the expression to interpret.
				\end{itemizeexamplecommand}
				\item[] Description: Creating double square bracketing for a meta language expression with a situation argument.
				\item[] Bold Option: Yes
				\item[] Example: \sdem{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Indirect Interpretation}
	This section covers commands for indirect semantic interpretation.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sic[situation]{constant}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\textit{i})}: the situation argument.
					\item[] \texttt{constant}: the function abbreviation.
				\end{itemizeexamplecommand}
				\item[] Description: Makes constant italic and adds an argument in the subscript.
				\item[] Bold Option: No (uppercase removes notational convention of subscript)
				\item[] Example: \sic{Q}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sicn[situation]{constant}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\textit{i})}: the situation argument.
					\item[] \texttt{constant}: the function abbreviation.
				\end{itemizeexamplecommand}
				\item[] Description: Makes negated constant italic and adds an argument in the subscript.
				\item[] Bold Option: Yes (c uppercase removes notational convention of subscript)
				\item[] Example: \sicn{Q}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sit[superscript][spacing]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to translate.
				\end{itemizeexamplecommand}
				\item[] Description: Creates single bar bracketing for indirect translation of an expression.
				\item[] Bold Option: Yes
				\item[] Example: \sit{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sitnobf{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to translate.
				\end{itemizeexamplecommand}
				\item[] Description: Creates single bar bracketing for indirect translation of an expression but without making the expression bold.
				\item[] Bold Option: Yes
				\item[] Example: \sitnobf{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sitnobfi{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to translate.
				\end{itemizeexamplecommand}
				\item[] Description: Creates single bar bracketing for indirect translation of an expression but making it italic and not bold.
				\item[] Bold Option: Yes
				\item[] Example: \sitnobfi{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sid[assignment][spacing]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{assignment}: the assignment function.
					\item[] \texttt{spacing(def=negthinspace)}: the spacing of the superscript to the brackets.
					\item[] \texttt{expression}: the expression to denote.
				\end{itemizeexamplecommand}
				\item[] Description: Creates double bar bracketing for indirect denotation of an expression with optional assignment function.
				\item[] Bold Option: Yes
				\item[] Example: \sid{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidg[assignmentReplacement][spacing][spacingAssignment]{expression}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{assignmentReplacement}: will be written behind the g.
					\item[] \texttt{spacing(def=negthinspace)}: the spacing of the superscript to the brackets.
					\item[] \texttt{spacingAssignment(def=negthinspace)}: the spacing between the var. in the assignment function.
					\item[] \texttt{expression}: the expression to denote.
				\end{itemizeexamplecommand}
				\item[] Description: Creates double bar bracketing for indirect denotation of an expression with \textit{g} a assignment function.
				\item[] Bold Option: Yes
				\item[] Example: \sidg{sleeps}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\asmod{replacement}[original][spacingAssignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{replacement}: the new variable to replace the original
					\item[] \texttt{original(def=x)}: the variable to be replaced
					\item[] \texttt{spacingAssignment(def=negthinspace)}: the spacing between the var. in the assignment function.
				\end{itemizeexamplecommand}
				\item[] Description: Creates an assignment function with a replacement.
				\item[] Bold Option: Yes
				\item[] Example: \asmod{r}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\asf{arg}[replacement1][original1][replacement2][original2][replacement3][original3][assignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}: argument to be assigned.
					\item[] \texttt{replacement1}: the new variable to replace the original
					\item[] \texttt{original1(def=x)}: the variable to be replaced
					\item[] \texttt{replacement2}: the new variable to replace the original
					\item[] \texttt{original2(def=y)}: the variable to be replaced
					\item[] \texttt{replacement3}: the new variable to replace the original
					\item[] \texttt{original3(def=z)}: the variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
				\end{itemizeexamplecommand}
				\item[] Description: Applies an argument to an assignment function and 3 optional replacement spots.
				\item[] Bold Option: Yes
				\item[] Example: \asf{p}[r][x]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidmod{expression}{replacement1}[original1][replacement2][original2][replacement3][original3][assignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to denote.
					\item[] \texttt{replacement1}: the new variable to replace the original
					\item[] \texttt{original1(def=x)}: the variable to be replaced
					\item[] \texttt{replacement2}: the new variable to replace the original
					\item[] \texttt{original2(def=y)}: the variable to be replaced
					\item[] \texttt{replacement3}: the new variable to replace the original
					\item[] \texttt{original3(def=z)}: the variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
				\end{itemizeexamplecommand}
				\item[] Description: Creates double bar bracketing for indirect denotation of an expression with \textit{g} as assignment function and 3 optional replacement spots. More specified versions of this function are
				\item[] Bold Option: Yes (case of d switches bracketing from bold to normal; case of o switches case of original variable from bold to normal)
				\item[] Example: \sidmod{test}{r}[x][b][u][h]
				\item[] Example: \sidmOD{test}{r}[x][b][u][h]}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidr{expression}{replacement}[original][assignment][spacingAssignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to denote.
					\item[] \texttt{replacement}: the new variable to replace the original
					\item[] \texttt{original(def=x)}: the variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
					\item[] \texttt{spacingAssignment(def=negthinspace)}: the spacing between the var. in the assignment function.
				\end{itemizeexamplecommand}
				\item[] Description: Creates double bar bracketing for indirect denotation of an expression with \textit{g} as assignment function and a replacement spot.
				\item[] Bold Option: Yes (case of d switches bracketing from bold to normal; case of r switches case of original variable from bold to normal)
				\item[] Example: \sidR{sleeps}{r}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidrr{expression}{replacement1}{replacement2}[original1][original2][assignment][spacingAssignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to denote.
					\item[] \texttt{replacement1}: the 1st new variable to replace the original
					\item[] \texttt{replacement2}: the 2nd new variable to replace the original
					\item[] \texttt{original1(def=x)}: the 1st variable to be replaced
					\item[] \texttt{original2(def=y)}: the 2nd variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
					\item[] \texttt{spacingAssignment(def=negthinspace)}: the spacing between the var. in the assignment function.
				\end{itemizeexamplecommand}
				\item[] Description: Creates double bar bracketing for indirect denotation of an expression with \textit{g} a assignment function and two replacement spots.
				\item[] Bold Option: Yes (case of d switches bracketing from bold to normal; case of r switches case of original variable from bold to normal)
				\item[] Example: \sidRR{sleeps}{r}{t}}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\sidrrr{expression}{replacement1}{replacement2}{replacement3}[original1][original2][original3][assignment][spacingAssignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{expression}: the expression to denote.
					\item[] \texttt{replacement1}: the 1st new variable to replace the original
					\item[] \texttt{replacement2}: the 2nd new variable to replace the original
					\item[] \texttt{replacement3}: the 3rd new variable to replace the original
					\item[] \texttt{original1(def=x)}: the 1st variable to be replaced
					\item[] \texttt{original2(def=y)}: the 2nd variable to be replaced
					\item[] \texttt{original3(def=z)}: the 3rd variable to be replaced
					\item[] \texttt{assignment(def=g)}: the assignment function
					\item[] \texttt{spacingAssignment(def=negthinspace)}: the spacing between the var. in the assignment function.
				\end{itemizeexamplecommand}
				\item[] Description: Creates double bar bracketing for indirect denotation of an expression with \textit{g} a assignment function and three replacement spots.
				\item[] Bold Option: Yes (case of d switches bracketing from bold to normal; case of r switches case of original variable from bold to normal)
				\item[] Example: \sidRRR{sleeps}{r}{t}{w}}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Rules}
	This section covers the most general rules for direct and indirect semantic interpretation along with some general rules used for derivation in compositional semantics.
	\subsection{Constants}
	This section will list all pre-defined \texttt{\her{fragoli}} commands acting as constants for common types or general symbols in semantics.
	\subsubsection{Situations}
	\texttt{\her{fragoli}} offers the most common situation variables for fast usage. The following are available: blank, \textit{*} and from \textit{0} to \textit{10}. Examples:
	\begin{center}
		\begin{minipage}[h][3.2cm][t]{15em}
			\begin{lstlisting}[style=B]
			\sblank
			\sblanK
			\sstar
			\sstaR
			\szero
			\szerO
			\sone
			\sonE
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.2cm][t]{15em}
			\ \\
			\sblank\\
			\sblanK\\
			\sstar\\
			\sstaR\\
			\szero\\
			\szerO\\
			\sone\\
			\sonE
		\end{minipage}
	\end{center}
	\subsubsection{Lambda Heads}
	\texttt{\her{fragoli}} offers a wide range of pre-defined lambda heads for fast usage. All heads are available in a lower- and uppercase version as well as a normal and bold version. E.g. \verb=\lmds= will create \zit{\lmds}. The last letter defines the lambda head variable; If the last letter is uppercase, the head variable will also be uppercase. The case of \zit{d} defines if the head is bold (uppercase) or normal (lowercase). The following letters are available: \zit{a-z}. Example for all \textit{p} versions:
	\begin{center}
		\begin{minipage}[h][1.6cm][t]{15em}
			\begin{lstlisting}[style=B]
			\lmdp
			\lmDp
			\lmdP
			\lmDP
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][1.6cm][t]{15em}
			\ \\\lmdp\\
			\lmDp\\
			\lmdP\\
			\lmDP
		\end{minipage}
	\end{center}
	\subsubsection{Types}
	\texttt{\her{fragoli}} offers a set of predefined types - covering the most common ones. These constants will not be affected by the package option \textit{usetypes} and will also be displayed if \textit{usetypes=false}. If you want them to only be displayed if \textit{usetypes=true}, add an @ after the backslash (e.g. \verb=\@typet=). The parentheses style will be affected by the package option \textit{typestyle}. The syntax for these types is defined by the letter case of every letter following \textit{type}. Every adjacent letter with matching uppercase will be on the same level. E.g. \verb=\typeeET= vs. \verb=\typeEEt= will result in \typeeET\ vs. \typeEEt. For types with a depth greater than 3 the syntax will also contain \textit{l} \& \textit{r} as left and right parentheses. \verb=\typeletETrt= vs. \verb=\typeetlETtr= will result in \typeretETlt\ vs. \typeetrETtl. Examples:
	\begin{center}
		\begin{minipage}[h][5cm][t]{15em}
			\begin{lstlisting}[style=B]
			\typee
			\types
			\typed
			\typet
			\typeet
			\typett
			\typeSEt
			\typeeET
			\typeslEetr
			\typeretETlt
			\typeetrETtl
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][5cm][t]{15em}
			\ \\\typee\\
			\types\\
			\typet\\
			\typed\\
			\typeet\\
			\typett\\
			\typeSEt\\
			\typeeET\\
			\typesleETr\\
			\typeretETlt\\
			\typeetrETtl
		\end{minipage}
	\end{center}
	\subsubsection{Traces}
	\texttt{\her{fragoli}} also offers commands for the most common traces for fast usage. The following are available (also as bold option): 
	\begin{center}
		\begin{minipage}[h][3.2cm][t]{15em}
			\begin{lstlisting}[style=B]
			\tracex
			\tracey
			\tracez
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.2cm][t]{15em}
			\ \\
			\tracex\\
			\tracey\\
			\tracez
		\end{minipage}
	\end{center}
	For an uppercase version, write the last character in uppercase. For a bold version write the \textit{e} in \textit{trace} in uppercase.
	\section{Environments}
	This section provides an overview of all newly introduced environments. Most environments include a set of specialized commands that are only accessible within the respective environment. Some environments are restricted, meaning they can only be used within a specific parent environment.
	\subsection{fglfunc}\label{env:fglfunc}
	The \textit{fglfunc} environment should be used to create large functions in array notation. This env. supports nesting. The \textit{fgls} and \textit{rb} environments are not enabled. When nesting multiple times it is recommended to change the vertical spacing to at least 14. Be careful with line breaks within the env. as this can result in an additional blank row or compiling errors!
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{fglfunc}[functionName][verticalSpacing][domainMode]
				content...
			\end{fglfunc}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{functionName}: The main function name.
					\item[] \texttt{verticalSpacing(def=10)}: The vertical spacing between each row.
					\item[] \texttt{domainMode(def=n)}: The text formatting mode of the domains.
				\end{itemizeexamplecommand}
				\item[] Description: Creates an environment for fast and easy function creation. Possible domain modes are \textit{n/m/b} which stand for \textit{normal}, \textit{mathmode}, and \textit{bold}. They will effect the text formatting of each domain.
				\item[] New Commands: Yes
				\item[] Restricted: No
				\item[] Since: 1.1.1
				\item[] Example: See below.}
		\end{itemizeexamplecommand}
	\xe
	\\Example for a short nested function K:
	\begin{lstlisting}[style=B]
			\begin{fglfunc}[\sde{kisses}][15]
					\f{Peter}{
					\b{
						\f{Peter}{0}
						\f{Maria}{1}
						\f{Frida}{0}}\d}
					\f{Maria}{
					\b{
						\f{Peter}{0}
						\f{Maria}{0}
						\f{Frida}{0}}\d}
					\d
			\end{fglfunc}
	\end{lstlisting}
	The code above will result in the following array structure:\\
	\begin{fglfunc}[\sde{kisses}][15]
						\f{Peter}{
						\b{
							\f{Peter}{0}
							\f{Maria}{1}
							\f{Frida}{0}\d}}
						\f{Maria}{
						\b{
							\f{Peter}{1}
							\f{Maria}{0}
							\f{Frida}{0}\d}}
						\d
	\end{fglfunc}
	\subsubsection{Commands}
	A few short commands are provided for fast and easy to read code.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\f{domain}{range}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{domain}: The domain.
					\item[] \texttt{range}: the range.
				\end{itemizeexamplecommand}
				\item[] Description: Will create a new row in the array representing an assignment.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\b{function}[functionName]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{function}: A nested function.
					\item[] \texttt{functionName}: The nested function name.
				\end{itemizeexamplecommand}
				\item[] Description: Will create a box with left and right brackets for a new nested function. To manually add left or right brackets you can use \verb=\l= and \verb=\r=. Do not add line breaks inside the box command.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\d[domain][symbol][range]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{domain(def=$\vdots$)}: An optional domain.
					\item[] \texttt{symbol}: The function symbol.
					\item[] \texttt{range}: An optional range.
				\end{itemizeexamplecommand}
				\item[] Description: Will create a new row with optional parameters. Should be used to indicate infinity or to add comments.
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{rb}
	The colored parentheses environment is designed to improve readability in semantic derivations. Most modern integrated development environments feature a similar feature/plugin - called rainbow brackets. Parentheses on the same nesting level will receive the same color. Currently only \zit{()} are supported. After five levels of nesting the colors will repeat. Currently the feature is limited to parentheses directly written in the environment, those inserted by commands will not be affected (work in progress). Check the \href{https://ctan.org/pkg/rainbowbrackets}{rainbowbrackets} package for additional information and features.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{rb}
				scontent...
			\end{rb}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments: None
				\item[] Description: Parentheses on the same nesting level will receive the same color.
				\item[] New Commands: No
				\item[] Restricted: No
				\item[] Example: \begin{rb}(1(2((4((6(7))5))3)))\end{rb}}
		\end{itemizeexamplecommand}
	\xe
	\subsection{fgls}
	The fragoli-semantics environment is designed to improve speed and readability in semantic derivations by adding shortcuts and specialized versions of general commands.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{fgls}[situation]
				content...
			\end{fgls}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments: \begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: The situation which will be displayed on all commands that make use of a situation (e.g. \verb=\e{}=).
				\end{itemizeexamplecommand}
				\item[] Description: Adds shortcuts and specialized versions of general commands.
				\item[] New Commands: Yes
				\item[] Restricted: No}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\fglsem[situation]{formulae}[maxWidth][alignment]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: The situation which will be displayed on all commands that make use of a situation (e.g. \verb=\e{}=).
					\item[] \texttt{formulae}: The semantic formulae.
					\item[] \texttt{maxWidth(def=linewidth)}: The maximum width of the varwidth box.
					\item[] \texttt{alignment(def=same as varwidth default}:The vertical alignment of the varwidth box.
				\end{itemizeexamplecommand}
				\item[] Description: Command wrapper for the \textit{fgls} environment. Should be used for short formulae or formulae within text. Will remove initial indent and line breaks. Will put everything in an varwidth box.
				\item[] Since: 1.1.1
			}
	\end{itemizeexamplecommand}
	\pex\begin{itemizeexamplecommand}
		\item[] \begin{lstlisting}[style=B]
			\fglsemc[situation]{formulae}[maxWidth][alignment]
		\end{lstlisting}
		{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
				\item[] \texttt{situation(def=\sstar)}: The situation which will be displayed on all commands that make use of a situation (e.g. \verb=\e{}=).
				\item[] \texttt{formulae}: The semantic formulae.
				\item[] \texttt{maxWidth(def=linewidth)}: The maximum width of the varwidth box.
				\item[] \texttt{alignment(def=same as varwidth default}:The vertical alignment of the varwidth box.
			\end{itemizeexamplecommand}
			\item[] Description: Command wrapper for the \textit{fgls} environment. Colored parentheses is enabled Should be used for short formulae or formulae within text. Will remove initial indent and line breaks. Will put everything in an varwidth box.
			\item[] Bold mode: Yes (only effects colored parentheses)
			\item[] Since: 1.1.1
		}
	\end{itemizeexamplecommand}
	\xe
	\subsubsection{Constants}
	This section will list all pre-defined commands acting as constants for common types or general symbols in the \textit{fgls} environment.
	\begin{enumerate}
		\item Object Language\\\verb=\or= is currently not available.
		\begin{center}
			\begin{minipage}[h][6.5cm][t]{15em}
				\begin{lstlisting}[style=B]
			\ox
			\oy
			\oz
			\oi
			\oj
			\os
			\ot
			\og
			\od
			\oR
			\oq
			\op
			\x
			\y
			\z
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][6.5cm][t]{15em}
				\begin{fgls}
					\ \\
					\ox\\
					\oy\\
					\oz\\
					\oi\\
					\oj\\
					\os\\
					\ot\\
					\og\\
					\od\\
					\oR\\
					\oq\\
					\op\\
					\x\\
					\y\\
					\z
				\end{fgls}
			\end{minipage}
		\end{center}
		Each object language constant exists in two forms: lowercase and uppercase. The uppercase version is represented by capitalizing the second letter of the command. Additionally, each constant has a secondary mode that automatically adds a space following the constant. To activate this mode, capitalize the first letter of the command. Both forms can be used simultaneously. The letters x, y, and z have special single-character commands, as they are the most commonly used. As a trade-off, these letters do not have a secondary mode that automatically appends a space.
		\item Meta Language
		\begin{center}
			\begin{minipage}[h][6cm][t]{15em}
				\begin{lstlisting}[style=B]
			\mx
			\my
			\mz
			\mi
			\mj
			\ms
			\mt
			\mg
			\md
			\mr
			\mp
			\mq
			\mu
			\mv
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][6cm][t]{15em}
				\begin{fgls}
					\ \\
					\mx\\
					\my\\
					\mz\\
					\mi\\
					\mj\\
					\ms\\
					\mt\\
					\mg\\
					\md\\
					\mr\\
					\mp\\
					\mq\\
					\mu\\
					\mv
				\end{fgls}
			\end{minipage}
		\end{center}
		Each meta language constant exists in two forms: lowercase and uppercase. The uppercase version is represented by capitalizing the second letter of the command. Additionally, each constant has a secondary mode that automatically adds a space following the constant. To activate this mode, capitalize the first letter of the command. Both forms can be used simultaneously. To get the Greek letter $\mu$ use \verb=\greekmu=. For advanced existential quantifiers see Section \ref{sub:quantorcommands}.
		\item Logic \begin{center}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{lstlisting}[style=B]
			\qe
			\qu
			\qa
			\jn
			\jc
			\jd
			\ji
			\jj
			\jx
			\jb
			\jp
			\jt
			\jf
			\je
			\jo
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{fgls}
					\ \\
					\qe\\
					\qu\\
					\qa\\
					\jn\\
					\jc\\
					\jd\\
					\ji\\
					\jj\\
					\jx\\
					\jb\\
					\jp\\
					\jt\\
					\jf\\
					\je\\
					\jo
				\end{fgls}
			\end{minipage}
			
		\end{center}
		Every logic constant exists in two versions, normal and bold. For the bold version just write the second letter in uppercase. All junctor constants have a second mode that automatically adds a space behind them (for the arrows it adds a space on both sides). To use this mode just write the first letter in uppercase. Both versions can be combined.
		\item Set theory \begin{center}
			\begin{minipage}[h][4cm][t]{15em}
				\begin{lstlisting}[style=B]
			\ci
			\cd
			\ce
			\cb
			\cq
			\ca
			\cu
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][4cm][t]{15em}
				\begin{fgls}
					\ \\
					\ci\\
					\cd\\
					\ce\\
					\cb\\
					\cq\\
					\ca\\
					\cu
				\end{fgls}
			\end{minipage}
		\end{center}
		Every set notation exists in two versions, normal and bold. For the bold version just write the second letter in uppercase. All operators have a second mode that automatically adds a space behind them. To use this mode just write the first letter in uppercase. Both versions can be combined.
		\item Relations \begin{center}
			\begin{minipage}[h][4cm][t]{15em}
				\begin{lstlisting}[style=B]
			\rn
			\rg
			\rs
			\rp
			\rpe
			\rq
			\rqe
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][4cm][t]{15em}
				\begin{fgls}
					\ \\
					\rn\\
					\rg\\
					\rs\\
					\rp\\
					\rpe\\
					\rq\\
					\rqe
				\end{fgls}
			\end{minipage}
		\end{center}
		Every relation operator exists in two versions, normal and bold. For the bold version just write the last letter in uppercase. All operators have a second mode that automatically adds a space before and behind them. To use this mode just write the first letter in uppercase. Both versions can be combined.
		\item Arguments Variable
		\begin{center}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{lstlisting}[style=B]
			\ax
			\aX
			\ay
			\aY
			\az
			\aZ
			\ai
			\aI
			\as
			\aS
			\ad
			\aD
			\ar
			\aR
			\ap
			\aP
			\aq
			\aQ
			\ae
			\aE
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{fgls}
					\ \\
					\ax\\
					\aX\\
					\ay\\
					\aY\\
					\az\\
					\aZ\\
					\ai\\
					\aI\\
					\as\\
					\aS\\
					\ad\\
					\aD\\
					\ar\\
					\aR\\
					\ap\\
					\aP\\
					\aq\\
					\aQ\\
					\ae\\
					\aE
				\end{fgls}
			\end{minipage}
		\end{center}
		
		\begin{center}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{lstlisting}[style=B]
			\Ax
			\AX
			\Ay
			\AY
			\Az
			\AZ
			\Ai
			\AI
			\As
			\AS
			\Ad
			\AD
			\Ar
			\AR
			\Ap
			\AP
			\Aq
			\AQ
			\Ae
			\AE
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][8cm][t]{15em}
				\begin{fgls}
					\ \\
					\Ax\\
					\AX\\
					\Ay\\
					\AY\\
					\Az\\
					\AZ\\
					\Ai\\
					\AI\\
					\As\\
					\AS\\
					\Ad\\
					\AD\\
					\Ar\\
					\AR\\
					\Ap\\
					\AP\\
					\Aq\\
					\AQ\\
					\Ae\\
					\AE
				\end{fgls}
			\end{minipage}
		\end{center}
		\begin{center}
			\begin{minipage}[h][9cm][t]{15em}
				\begin{lstlisting}[style=B]
			\bx
			\bX
			\by
			\bY
			\bz
			\bZ
			\bi
			\bI
			\bs
			\bS
			\bd
			\bD
			\br
			\bR
			\bp
			\bP
			\bq
			\bQ
			\be
			\bE
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][9cm][t]{15em}
				\begin{fgls}
					\ \\
					\bx\\
					\bX\\
					\by\\
					\bY\\
					\bz\\
					\bZ\\
					\bi\\
					\bI\\
					\bs\\
					\bS\\
					\bd\\
					\bD\\
					\br\\
					\bR\\
					\bp\\
					\bP\\
					\bq\\
					\bQ\\
					\be\\
					\bE
				\end{fgls}
			\end{minipage}
		\end{center}
		\item Situations
		\\\verb=\cs= will always return the current situation set in the current fgls env. (def=\sstar)
		\begin{center}
			\begin{minipage}[h][2.5cm][t]{15em}
				\begin{lstlisting}[style=B]
			\ss
			\sz
			\so
			\st
			\si
				\end{lstlisting}
			\end{minipage}
			\begin{minipage}[h][2.5cm][t]{15em}
				\begin{fgls}
					\ \\
					\ss\\
					\sz\\
					\so\\
					\st\\
					\si
				\end{fgls}
			\end{minipage}
		\end{center}
	Each situation constant exists in two forms: normal and bold. The bold version is represented by capitalizing the second letter of the command. Additionally, each situation constant has a secondary mode, which automatically adds a space following the constant. To activate this mode, capitalize the first letter of the command. Both forms can be used simultaneously. It is important to note that the symbol \textit{i} has a special rule: when the first letter is lowercase, the constant is always represented in subscript, while the version with an uppercase first letter is treated as a normal variable with an added space at the end.
	\item Traces
		\begin{center}
			\begin{minipage}[h][2.2cm][t]{15em}
				\begin{lstlisting}[style=B]
			\tx
			\ty
			\tz
				\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][2.2cm][t]{15em}
			\begin{fgls}
				\ \\
				\tx\\
				\ty\\
				\tz
			\end{fgls}
		\end{minipage}
	\end{center}
	Each trace constant exists in multiple forms: normal, bold, uppercase, and with an additional space (each combination is possible). The bold version is represented by capitalizing the first letter of the command. The uppercase version is represented by capitalizing the second letter of the command. Additionally, each situation constant has a secondary mode, which automatically adds a space following the constant. To activate this mode, append an additional \textit{s} to the command (e.g. \verb=\txs=).
	\item Types \label{ex:typeshortcuts}
	\begin{center}
		\begin{minipage}[h][3cm][t]{15em}
			\begin{lstlisting}[style=B]
			\te
			\tet
			\teET
			\ts
			\tst
			\tse
			\tt
			\ttt
			\td
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3cm][t]{15em}
			\begin{fgls}
				\ \\
				\typee\\
				\typeet\\
				\typeeET\\
				\types\\
				\typest\\
				\typese\\
				\typet\\
				\typett\\
				\typed
			\end{fgls}
		\end{minipage}
	\end{center}
	Shortcuts for the most common types. Since the original command is already short, only the most common ones got even shorter commands. Those shortcuts are also available inside the \verb=\type{type}= command.
	\end{enumerate}
	\subsubsection{Commands}
		Text-Commands:
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\o{text}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{text}: Text to format.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\obl{text}=
					\item[] Bold Option: No
					\item[] Example: \obl{text}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\v{text}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{text}: Text to format.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\obli{text}=
					\item[] Bold Option: No
					\item[] Example: \obli{text}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\m{text}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{text}:  Text to format.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\mel{text}=
					\item[] Bold Option: No
					\item[] Example: \mel{text}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\j{text}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{text}:  Text to format.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\meli{text}=
					\item[] Bold Option: No
					\item[] Example: \meli{text}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sub{text}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}:  Text for italic subscript.
				\end{itemizeexamplecommand}
				\item[] Description: Shortcut for \verb=\ensuremath{_{text}}=
				\item[] Bold Option: Yes
				\item[] Example: \fglsem{\sub{text}}}
		\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sup{text}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}:  Text for italic superscript.
				\end{itemizeexamplecommand}
				\item[] Description: Shortcut for \verb=\ensuremath{^{text}}=
				\item[] Bold Option: Yes
				\item[] Example: \fglsem{\sup{text}}}
		\end{itemizeexamplecommand}
		\xe
		Argument-Commands:
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\a{arg}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{arg}:  object language variable as argument.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\obl{(}\obli{arg}\obl{)}=
					\item[] Bold Option: No
					\item[] Example: \obl{(}\obli{a}\obl{)}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\A{arg}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{arg}:  object language constant as argument.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\obl{(arg)}=
					\item[] Bold Option: No
					\item[] Example: \obl{(a)}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\ab{arg}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg}:  object language variable as argument with bold brackets.
				\end{itemizeexamplecommand}
				\item[] Description: Shortcut for \verb=\B{\obli{arg}}=
				\item[] Bold Option: Yes (makes art non italic)
				\item[] Example: \fglsem{\ab{a}}}
		\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\sa{function}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{function}:  the characteristic function.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sarrow{function}=
					\item[] Bold Option: Yes
					\item[] Example: \sarrow{\sde{Peter}}}
			\end{itemizeexamplecommand}
		\xe
		Lambda-Commands:
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfx{word}[lambdaBody][lambdaHead][situation][headType]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\texttt{lambdaHead} \texttt{word} in \sstar}.
						\item[] \texttt{lambdaHead(def=x)}:  the lambda head variable
						\item[] \texttt{situation(def=\sstar)}:  the situation inside the lambda body.
						\item[] \texttt{headType}:  the lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \verb=\lambfx{lambdaBody}[lambdaHead][headType]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfx{\textit{x} sleeps in \sstar}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfy{word}[lambdaBody][lambdaHead1][lambdaHead2][situation][headType1][headType2]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\texttt{lambdaHead1} \texttt{word} \texttt{lambdaHead2} in \sstar}.
						\item[] \texttt{lambdaHead1(def=y)}:  the first lambda head variable
						\item[] \texttt{lambdaHead2(def=x)}:  the second lambda head variable
						\item[] \texttt{situation(def=\sstar)}:  the situation inside the lambda body
						\item[] \texttt{headType1}:  the first lambda head type
						\item[] \texttt{headType2}:  the second lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \verb=\lambfyx{lambdaBody}[lambdaHead1][lambdaHead2][headType1][headType2]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfyx{\textit{x} kills \textit{y} in \sstar}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfz{word}[lambdaBody][lambdaHead1][lambdaHead2][lambdaHead3][situation][headType1][headType2][headType3]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\textit{lambdaHead1} \texttt{word} \texttt{lambdaHead2} \textit{lambdaHead3} in \sstar}.
						\item[] \texttt{lambdaHead1(def=z)}:  the first lambda head variable
						\item[] \texttt{lambdaHead2(def=y)}:  the second lambda head variable
						\item[] \texttt{lambdaHead3(def=x)}:  the third lambda head variable
						\item[] \texttt{situation(def=\sstar)}:  the situation inside the lambda body
						\item[] \texttt{headType1}:  the first lambda head type
						\item[] \texttt{headType2}:  the second lambda head type
						\item[] \texttt{headType3}:  the third lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \verb=\lambfzyx{lambBody}[lambHead1][lambHead2][lambHead3][headType1][headType2][headType3]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfzyx{\textit{x} gives \textit{y} \textit{z} in \sstar}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfsx{word}[lambdaBody][situationHead][lambdaHead2][situationType][headType2]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\texttt{lambdaHead2} \texttt{word} in \texttt{situationHead}}.
						\item[] \texttt{situationHead(def=s)}:  the situation lambda head variable
						\item[] \texttt{lambdaHead2(def=x)}:  the second lambda head variable
						\item[] \texttt{headType1}:  the situation lambda head type (should be used if type should be displayed)
						\item[] \texttt{headType2}:  the second lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \verb=\lambfsx{lambdaBody}[lambdaHead1][lambdaHead2][headType1][headType2]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfsx{\textit{x} sleeps in \sblank}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfsy{word}[lambdaBody][situationHead][lambdaHead2][lambdaHead3][situationType][headType2][headType3]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \zit{\texttt{lambdaHead3} \texttt{word} \texttt{lambdaHead2} in \texttt{situationHead}}.
						\item[] \texttt{situationHead(def=s)}:  the situation lambda head variable
						\item[] \texttt{lambdaHead2(def=y)}:  the second lambda head variable
						\item[] \texttt{lambdaHead3(def=x)}:  the third lambda head variable
						\item[] \texttt{headType1}:  the situation lambda head type (should be used if type should be displayed)
						\item[] \texttt{headType3}:  the second lambda head type
						\item[] \texttt{headType3}:  the third lambda head type
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \\\verb=\lambfsyx{lambdaBody}[lambdaHead1][lambdaHead2][lambdaHead3][headType1][headType2][headType3]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfsyx{\textit{x} kills \textit{y} in \sblank}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lfsz{word}[lambdaBody][situationHead][lambdaHead2][lambdaHead3][lambdaHead4][situationHead][headType2][headType3]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{word}:  the word to create the function for
						\item[] \texttt{lambdaBody}:  the lambda function body, if empty the body will be \\\zit{\texttt{lambdaHead4} \texttt{word} \texttt{lambdaHead3} \texttt{lambdaHead2} in \texttt{situationHead}}.
						\item[] \texttt{situationHead(def=s)}:  the situation lambda head variable
						\item[] \texttt{lambdaHead2(def=z)}:  the second lambda head variable
						\item[] \texttt{lambdaHead3(def=y)}:  the third lambda head variable
						\item[] \texttt{lambdaHead4(def=x)}:  the fourth lambda head variable
						\item[] \texttt{headType1}:  the situation lambda head type (should be used if type should be displayed)
						\item[] \texttt{headType2}:  the second lambda head type
						\item[] \texttt{headType3}:  the third lambda head type (fourth lambda head will get the same type due to the 9 args limit in LaTeX)
					\end{itemizeexamplecommand}
					\item[] Description: Specialized version of \\\verb=\lambfszyx{lambdaBody}[lambdaHead1][lambdaHead2][lambdaHead3][lambdaHead4][headType1][headType2][headType3][headType4]=
					\item[] Bold Option: Yes
					\item[] Example: \lambfszyx{\textit{x} gives \textit{y} \textit{z} in \sblank}}
			\end{itemizeexamplecommand}
		\xe
		There are pre-defined lambda heads for the most common variables and quantors. Each one has four different versions which can been seen below for the example of x. The variables are: \textit{x,y,z,p,q,r,s,t,d,i,u,v}.
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\lx[type]
			\lX[type]
			\Lx[type]
			\LX[type]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{type}:  type of the lambda head variable
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\lambh{var}[type]=
					\item[] Bold Option: Yes (first letter defines if the lambda head is bold, second letter defines the lambda head variable)
					\item[] Example: \lambh{x}, \lambh{X}, \lambH{x}, \lambH{X}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\lha[variable][type]
			\lhan[variable][type]
			\lhe[variable][type]
			\lhen[variable][type]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{variable}:  the variable bound by the quantor
					\item[] \texttt{type}:  type of the lambda head variable
				\end{itemizeexamplecommand}
				\item[] Description: Shortcut for various lambda heads with quantifiers.
				\item[] Bold Option: Yes
				\item[] Example: \fglsem{\lha, \lhA, \lhan, \lhaN, \lhe, \lhE, \lhen, \lheN}}
		\end{itemizeexamplecommand}
		\xe
		Derivation-Commands:
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\r[subInner][subOuter]{arg}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{subInner}: Optional subscript behind opening bracket. Text will be in mathmode. (mostly used in tree like structures)
						\item[] \texttt{subOuter}: Optional subscript behind closing bracket. Text will be in mathmode (mostly used to identify types)
						\item[] \texttt{arg}:  term inside rectangular brackets.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\lambby{arg}=
					\item[] Bold Option: Yes
					\item[] Example: \lambby{arg}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\b{text}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{text}:  text inside normal brackets.
				\end{itemizeexamplecommand}
				\item[] Description: Shortcut for \verb=(text)=. Should be used mostly for bold mode or within a \textit{rb} env. for brackets that one does not want to be colored. 
				\item[] Bold Option: Yes
				\item[] Example: (text)}
		\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\n{arg}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{arg}:  term inside truth value brackets.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\bool{arg}=
					\item[] Bold Option: Yes
					\item[] Example: \bool{arg}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\s{arg}[var]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{arg}:  Set-builder notation
						\item[] \texttt{var(def=x)}: Variable name and/or domain specifier
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\set[var]{arg}=. To write the set variable use \verb=\sv= or \\\verb=\Sv= for the version with an extra space appended.
					\item[] Bold Option: Yes
					\item[] Example: \verb=\s{\Sv is a dog}=  will result in: \set{\Setvar is a dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\i{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to interpret.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sdi{arg}=
					\item[] Bold Option: Yes
					\item[] Example: \sdi{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\e[situation]{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{situation(def=\sstar)}:  the situation.
						\item[] \texttt{expression}:  the expression to interpret.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sde[situation]{arg}=
					\item[] Bold Option: Yes
					\item[] Example: \sde{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\c[situation]{constant}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{situation(def=$i$)}:  the situation.
						\item[] \texttt{constant}:  the constant.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sic[situation]{constant}=
					\item[] Bold Option: No (Uppercase version removes notational convention)
					\item[] Example: \sic{S}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\t{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to translate.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sit{expression}=
					\item[] Bold Option: Yes
					\item[] Example: \sit{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\ti{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to translate.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sit{\textit{expression}}=
					\item[] Bold Option: Yes
					\item[] Example: \sit{\textit{Dog}}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\tb{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to translate.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sitnobf{expression}=
					\item[] Bold Option: Yes
					\item[] Example: \sitnobf{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\tbi{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}:  the expression to translate.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sitnobfi{expression}=
					\item[] Bold Option: Yes
					\item[] Example: \sitnobfi{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\h{type}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{type}: the Ty2 type.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\type{type}=
					\item[] Bold Option: Yes
					\item[] Example: \type{et}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\d[assignment]{expression}
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{assignment(def=g)}: the assignment function.
						\item[] \texttt{expression}: the expression to denote.
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sid[assignment]{expression}=
					\item[] Bold Option: Yes
					\item[] Example: \sid[g]{Dog}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\dr{expression}[replacement][assignment][original]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}: the expression to denote.
						\item[] \texttt{replacement(def=r)}: the variable to replace the original with.
						\item[] \texttt{assignment(def=g)}: the assignment function.
						\item[] \texttt{original(def=x)}: the original argument to be replaced
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sidr{expression}{replacement}[original][assignment]=
					\item[] Bold Option: No (Uppercase makes original variable bold)
					\item[] Example: \sidr{Dog}{r}[x][g]}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\drr{expression}[replacement1][replacement2][assignment][original1][original2]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}: the expression to denote.
						\item[] \texttt{replacement1(def=r)}: the first variable to replace the original with.
						\item[] \texttt{replacement2(def=d)}: the second variable to replace the original with.
						\item[] \texttt{assignment(def=g)}: the assignment function.
						\item[] \texttt{original1(def=x)}: the fist original argument to be replaced
						\item[] \texttt{original2(def=y)}: the second original argument to be replaced
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for \verb=\sidrr{expression}{replacement1}{replacement2}[original1][original2][assignment]=
					\item[] Bold Option: No (Uppercase makes original variable bold)
					\item[] Example: \sidrr{Dog}{r}{d}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\drrr{expression}[replacement1][replacement2][replacement3][assignment][original1][original2][original3]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{expression}: the expression to denote.
						\item[] \texttt{replacement1(def=r)}: the first variable to replace the original with.
						\item[] \texttt{replacement2(def=d)}: the second variable to replace the original with.
						\item[] \texttt{replacement3(def=t)}: the third variable to replace the original with.
						\item[] \texttt{assignment(def=g)}: the assignment function.
						\item[] \texttt{original1(def=x)}: the fist original argument to be replaced
						\item[] \texttt{original2(def=y)}: the second original argument to be replaced
						\item[] \texttt{original3(def=z)}: the third original argument to be replaced
					\end{itemizeexamplecommand}
					\item[] Description: Shortcut for\\ \verb=\sidrrr{expression}{replacement1}{replacement2}{replacement3}[original1][original2][original3][assignment]=
					\item[] Bold Option: No (Uppercase makes original variable bold)
					\item[] Example: \sidrrr{Dog}{r}{d}{t}}
			\end{itemizeexamplecommand}
		\xe
		Quantifier-Commands:\label{sub:quantorcommands}
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\qe[relation][value]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{relation}:  the mathematical relation (mathmode already enabled)
						\item[] \texttt{value}:  the numerical value
					\end{itemizeexamplecommand}
					\item[] Description: Creates an existential quantifier with additional parameters.
					\item[] Bold Option: Yes
					\item[] Space Option: Yes	
					\item[] Since: 1.1.1				
					\item[] Example: \begin{fgls}\qE[>][1]\end{fgls}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\qeg[value]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{value(def=2)}:  the numerical value
					\end{itemizeexamplecommand}
					\item[] Description: Creates an existential quantifier with a greater than or equal to parameter.
					\item[] Bold Option: Yes
					\item[] Space Option: Yes
					\item[] Since: 1.1.1
					\item[] Example: \begin{fgls}\qeg\end{fgls}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\qes[value]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{value(def=2)}:  the numerical value
					\end{itemizeexamplecommand}
					\item[] Description: Creates an existential quantifier with a smaller than or equal to parameter.
					\item[] Bold Option: Yes
					\item[] Space Option: Yes
					\item[] Since: 1.1.1
					\item[] Example: \begin{fgls}\qes\end{fgls}}
			\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
				\item[]
				\begin{lstlisting}[style=B]
			\qee[value]
				\end{lstlisting}
				{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{value(def=2)}:  the numerical value
					\end{itemizeexamplecommand}
					\item[] Description: Creates an existential quantifier with an equal to parameter.
					\item[] Bold Option: Yes
					\item[] Space Option: Yes
					\item[] Since: 1.1.1
					\item[] Example: \begin{fgls}\qee\end{fgls}}
			\end{itemizeexamplecommand}
		\xe
	\subsection{semderivation}
	The \textit{semantic-derivation} environment is the heart of the \FraGoLi\ package and is used for fast and easy derivation of a direct or indirect semantic expressions. The \textit{fgls} and \textit{rb} env. are enabled automatically.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semderivation}[situation][label][rainbowbracketStyle]
				content...
			\end{semderivation}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=global-situation)}: The default situation for this derivation.
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
					\item[] \texttt{rainbowbracketStyle(def=n)}: Change the default rainbowbracket style. Possible values are \zit{b} or \zit{i} for bold or italic. For example in b mode, all parentheses will be replaced with bold parentheses.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for easy derivation of direct or indirect semantic expressions.
				\item[] New Commands: Yes
				\item[] Bold Mode: Yes (just sets b as default rainbowbracketStyle)
				\item[] Restricted: No}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Constants}
	This section lists all predefined commands that serve as constants for common derivation steps within the \textit{semderivation} environment. These commands are intended to be used as sidenotes. If the language is changed via the package options, the constants will be automatically translated and abbreviated. Some of these are interchangeable.
	\begin{center}
		\begin{minipage}[h][4.6cm][t]{15em}
			\begin{lstlisting}[style=B]
			\alp
			\bta
			\fa
			\abs
			\mod
			\var
			\con
			\id
			\lc
			\nc
			\lex
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][4.6cm][t]{15em}
			\begin{fgls}
				\ \\
				\ensuremath{\alpha}-conversion\\
				\ensuremath{\beta}-reduction\\
				Functional application\\
				Abstraction\\
				Modification\\
				Variable assignment\\
				Con\\
				Id\\
				\ensuremath{\lambda}-conversion\\
				Notation convention\\
				lexical trees
			\end{fgls}
		\end{minipage}
	\end{center}
	\subsubsection{Commands}
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\ds[sidenote]{derivationRow}[itemLabel]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{derivationRow}: The derivational step performed.
					\item[] \texttt{itemLabel}: The itemize item label for the current step, if blank the label will be an equal sign with the current row number on top.
				\end{itemizeexamplecommand}
				\item[] Description: Adds a new step to the derivation without the equals and row counter, should therefore be used as first row
				\item[] Bold Option: No (Uppercase removes equals and row counter, should be used as first step to indicate the beginning)
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\cdr
			\end{lstlisting}
			{\scriptsize\item[] Arguments: none
				\item[] Description: Returns the current derivation reference string. For example sem:deri:3 if used in the third derivation env. or sem:deri:derithree if used in a semcalc env with derithree as refName argument.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
		\item[]
			\begin{lstlisting}[style=B]
			\rbb
			\rbi
			\rbn
			\rbr
			\end{lstlisting}
		{\scriptsize\item[] Arguments: none
			\item[] Description: Change the rainbowbrackets mode within a single derivational step. Commands represent abriviations for \\\verb=\rbsetboldmode=, \verb=\rbresetmode=, \verb=\rbsetnormalmode=, and \verb=\rbsetitalicmode=. Both \verb=\ds= and \verb=\dS= call \verb=\rbresetmode= at the end to reset. See \href{https://ctan.org/pkg/rainbowbrackets}{rainbowbrackets} package for additional information.
		}
	\end{itemizeexamplecommand}
	\xe
	\subsection{semcalc}\label{sec:semcalc}
	The \textit{semantic-calculation} environment is designed to improve speed and to provide a clear structure for a full semantic derivation. If not specified otherwise via a package option, \textit{rb} is enabled in the \textit{semderi} environment. The \textit{fgls} shortcuts are enabled.
	
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semcalc}[situation][refName]
				content...
			\end{semcalc}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments: \begin{itemizeexamplecommand}
					\item[] \texttt{situation(def=\sstar)}: The situation which will be displayed on all extensions. The default value is set by the situation package parameter.
					\item[] \texttt{refName(def=@fglsderivationcounter)}: The reference name used in the automatic labels that will be created for each resource entry (e.g. rules, lexicon, etc.) and derivation step. By default fragoli will start at 1 and increase each time a new semantic derivation is created (including semderivation and semderi env.).
				\end{itemizeexamplecommand}
				\item[] Description: Adds shortcuts and specialized versions of general commands.
				\item[] New Commands: Yes
				\item[] Restricted: No}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Commands}
	Both \textit{resource-entry} commands should be used inside the \textit{semrule} and \textit{semlex} environment to add a rule or lexicon entry to the derivation. The side note information should reference the origin of a rule or lexicon entry (e.g. from a script or paper) or to reference the rule or lexicon entry used in a derivational step.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rentry[sidenote]{resourceEntry}[label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{resourceEntry}: The resource entry (either a rule or a lexicon entry)
					\item[] \texttt{label}: The item label, if blank the label will be R/L + the current rule/lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: Add either a rule or a lexicon entry.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rentrysub[sidenote]{resourceSubEntry}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{resourceSubEntry}: Detailed information for a resource entry.
				\end{itemizeexamplecommand}
				\item[] Description: Give additional information about a rule or a lexicon entry.
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\label{command:resourceCounter}\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rr{resourceCounter}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{resourceCounter}: The number of the rule to be referenced
				\end{itemizeexamplecommand}
				\item[] Description: Creates a reference to the rule specified. Its the short version of \verb=\ref{\cdr:r:number}=. For a lexicon entry use \verb=\rl{resourceCounter}=, for a language entry use \verb=\rla{resourceCounter}=, for a syntactic rule entry use \verb=\rrs{resourceCounter}=
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\cdr
			\end{lstlisting}
			{\scriptsize\item[] Arguments: none
				\item[] Description: Returns the current derivation reference string. For example sem:deri:3 if used in the third derivation env. or sem:deri:derithree if used in a semcalc env with derithree as refName argument.
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semlang}
	The \textit{semantic-lang} environment is an optional environment to define the language for any derivation of a direct or indirect semantic expressions. So far no custom commands are implemented. Each language gets automatically label (if used via \verb=\rentry= or predefined language command) with the following pattern: "sem:deri:refName:la:rulecounter". So the first language in the second semcalc env. will have the following label: "sem:deri:2:la:1" assuming that no custom refName has been set.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semlang}[label]
				content...
			\end{semlang}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= in front.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for defining the language your working in for this current derivation.
				\item[] New Commands: Yes
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Commands}
	The \FraGoLi\ package offers a quick builder to create a language based of sets of lexical entries.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rlang{entires}[setOne][setTwo][setThree][setFour][setFive][setSix][setSeven][setEight][symbol]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{entires}: Every element of the language, separated by a comma.
					\item[] \texttt{setOne}: An optional set of entries to group similar ones.
					\item[] \texttt{setTwo}: An optional set of entries to group similar ones.
					\item[] \texttt{setThree}: An optional set of entries to group similar ones.
					\item[] \texttt{setFour}: An optional set of entries to group similar ones.
					\item[] \texttt{setFive}: An optional set of entries to group similar ones.
					\item[] \texttt{setSix}: An optional set of entries to group similar ones.
					\item[] \texttt{setSeve}: An optional set of entries to group similar ones.
					\item[] \texttt{setEigth}: An optional set of entries to group similar ones.
					\item[] \texttt{symbol(def=L)}: The symbol for the main language set.
				\end{itemizeexamplecommand}
				\item[] Description: Builds a set that defines the language. If any optional set is added, they will all be unified.
				\item[] Example: \verb=\rlang{Peter, Maria, liebt}[NN][VP]= Result: L = L\textsubscript{NN} $\cup$ L\textsubscript{VP} = \{Peter, Maria, liebt\} 
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semtree}
	The \textit{semantic-tree} environment is an optional environment to add general tree structures to any derivation of a direct or indirect semantic expressions. So far no custom tree generating
	commands are implemented, all tree packages should work but \textit{forest} package is tested best and recommended.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semtree}[label]
				content...
			\end{semtree}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for additional trees of semantic expressions.
				\item[] New Commands: No
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semtreesem}
		The \textit{semantic-tree-semantic} environment is a specialized version of the \textit{semantic-tree} env. and should be used for semantic trees. So far no custom tree generating commands are implemented, all tree packages should work but \textit{forest} package is tested best and recommended.
		\pex
			\ex \begin{itemizeexamplecommand}
				\item[] \begin{lstlisting}[style=B]
				\begin{semtreesem}[label]
					content...
				\end{semtreesem}
				\end{lstlisting}
				{\scriptsize
					\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= in front.
					\end{itemizeexamplecommand}
					\item[] Description: Env. for additional semantic trees of semantic expressions.
					\item[] New Commands: No
					\item[] Restricted: Yes (semcalc)}
			\end{itemizeexamplecommand}
		\xe
	\subsection{semtreesyn}
		The \textit{semantic-tree-syntactic} environment is a specialized version of the \textit{semantic-tree} env. and should be used for syntactic trees. So far no custom tree generating commands are implemented, all tree packages should work but \textit{forest} package is tested best and recommended.
		\pex
			\ex \begin{itemizeexamplecommand}
				\item[] \begin{lstlisting}[style=B]
				\begin{semtreesyn}[label]
					content...
				\end{semtreesyn}
				\end{lstlisting}
				{\scriptsize
					\item[] Arguments:\begin{itemizeexamplecommand}
						\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= infront.
					\end{itemizeexamplecommand}
					\item[] Description: Env. for additional syntactic trees of semantic expressions.
					\item[] New Commands: No
					\item[] Restricted: Yes (semcalc)}
			\end{itemizeexamplecommand}
		\xe
	\subsection{semrule}
	The \textit{semantic-rules} environment is used to list all rules used for a derivation of a direct or indirect semantic expressions. Each rule gets automatically label (if used via \verb=\rentry= or predefined rule) with the following pattern: "sem:deri:refNamer:rulecounter". So the first rule in the second semcalc env. will have the following label: "sem:deri:2:r:1" assuming that no custom refName has been set.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semrule}[label][situation]
				content...
			\end{semrule}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= in front.
					\item[] \texttt{situation(def=$s$)}: The situation which will be displayed on all extensions. The default value is set by the rulesituation package parameter.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for easy listing of semantic derivation rules.
				\item[] New Commands: Yes
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Commands}
	The \FraGoLi\ package offers the most common semantic rules for both direct and indirect in\-ter\-pre\-ta\-ti\-on based on the accompanying material to an introductory course to linguistic semantics by \textit{Thomas Ede Zimmermann}. All pre-defined rules can be customized with aspect to variables and lambda heads. General commands for fast rule creation are also featured. All commands start with rsr (resource semantic rule) followed by a categorization into general/direct/indirect e.g. \verb=\rsrgarrow= for \texttt{resource-semantic-rule-general-arrow}. All pre-defined rules have the option to add a side note. If the package option usetypes is enabled all pre-defined rules will show the type on each lambda head. All rules are based on their basic versions just wrapped inside a resource entry command.
	\\Currently the command category abbreviation are:
	\begin{center}
		\begin{minipage}[h][3.3cm][t]{10em}
			\begin{lstlisting}[style=B]
			rsrg
			rsrde
			rsrdeqr
			rsrdi
			rsrit
			rsrid
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.3cm][t]{30em}
			\begin{fgls}
				\ \\
				resource-semantic-rule-general\\
				resource-semantic-rule-direct-exenstion\\
				resource-semantic-rule-direct-extension-quantifier-raising\\
				resource-semantic-rule-direct-intension\\
				resource-semantic-rule-indirect-translation\\
				resource-semantic-rule-indirect-denotation
			\end{fgls}
		\end{minipage}
	\end{center}
	General Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrgarrow[sidenote]{var}{function}
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var(def=x)}: Variable.
					\item[] \texttt{function(def=f)}: Function.
				\end{itemizeexamplecommand}
				\item[] Description: Give additional information about a rule or a lexicon entry.
				\item[] Example: \verb=\rsrgarrow= \begin{semcalc}\begin{semrule}[ ]\rsrgarrow\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Direct Interpretation Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrde{arg1}{arg2}[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: left argument.
					\item[] \texttt{arg2}: right argument.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation extension rule.
				\item[] Example: \verb=\rsrde{Left}{Right}= \begin{semcalc}\begin{semrule}[ ]\rsrde{Left}{Right}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdi{arg1}{arg2}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{arg1}: left argument.
					\item[] \texttt{arg2}: right argument.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdi{Left}{Right}= \begin{semcalc}\begin{semrule}[ ]\rsrdi{Left}{Right}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdesbjpred[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdesbjpred= \begin{semcalc}\begin{semrule}[ ]\rsrdesbjpred\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdesbjquant[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdesbjquant= \begin{semcalc}\begin{semrule}[ ]\rsrdesbjquant\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeobjpred[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdeobjpred= \begin{semcalc}\begin{semrule}[ ]\rsrdeobjpred\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeobjquant[sidenote][arg1][arg2][situation][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{arg1(def=x)}: The first argument.
					\item[] \texttt{arg2(def=y)}: The second argument.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{type1(def=\type{e})}: The type of the first argument
					\item[] \texttt{type2(def=\type{e})}: The type of the second argument
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdeobjquant= \begin{semcalc}\begin{semrule}[ ]\rsrdeobjquant\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdequant[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdequant= \begin{semcalc}\begin{semrule}[]\rsrdequant\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdecoordination[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdecoordination= \begin{semcalc}\begin{semrule}[ ]\rsrdecoordination\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdiconva[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=$s$)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdiconva= \begin{semcalc}\begin{semrule}[ ]\rsrdiconva\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdiconvb[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=$s$)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdiconvb= \begin{semcalc}\begin{semrule}[ ]\rsrdiconvb\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeattitude[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=$s$)}: The situation.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrdeattitude= \begin{semcalc}\begin{semrule}[ ]\rsrdeattitude\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Indirect Interpretation Translation Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrit{left}{right}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument.
					\item[] \texttt{right}: Right argument
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrit{Left}{Right}= \begin{semcalc}\begin{semrule}[ ]\rsrit{Left}{Right}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsriti{left}{right}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument.
					\item[] \texttt{right}: Right argument
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsriti{Left}{Right}= \begin{semcalc}\begin{semrule}[ ]\rsriti{Left}{Right}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritibasic{left}{right}{rightArg}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument.
					\item[] \texttt{right}: Right argument
					\item[] \texttt{rightArg}: Argument on the right side.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritibasic{Left}{Right}{Arg}= \begin{semcalc}\begin{semrule}[ ]\rsritibasic{Left}{Right}{Arg}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritcoordination[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritcoordination= \begin{semcalc}\begin{semrule}[ ]\rsritcoordination\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritpredication[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritpredication= \begin{semcalc}\begin{semrule}[ ]\rsritpredication\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritnamedirectobject[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritnamedirectobject= \begin{semcalc}\begin{semrule}[ ]\rsritnamedirectobject\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritquantification[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritquantification= \begin{semcalc}\begin{semrule}[ ]\rsritquantification\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritquantificational[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritquantificational= \begin{semcalc}\begin{semrule}[ ]\rsritquantificational\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritquantificationasobj[sidenote][arg1][arg2][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{arg1(def=x)}: First argument.
					\item[] \texttt{arg1(def=y)}: Second argument.
					\item[] \texttt{type1(def=\type{et})}: Type of the first argument
					\item[] \texttt{type2(def=\type{et})}: Type of the second argument
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritquantificationasobj= \begin{semcalc}\begin{semrule}[ ]\rsritquantificationasobj\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritattitude[sidenote][situation][situationType][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=i)}: The situation.
					\item[] \texttt{situationType(def=\type{s})}: The situation type (should be used to always display type).
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritattitude= \begin{semcalc}\begin{semrule}[ ]\rsritattitude\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritraisedsubj[sidenote][situation][situationType][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=i)}: The situation.
					\item[] \texttt{situationType(def=\type{s})}: The situation type (should be used to always display type).
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritraisedsubj= \begin{semcalc}\begin{semrule}[ ]\rsritraisedsubj\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsritcontrolverbs[sidenote][arg1][arg2][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{arg1(def=x)}: First argument.
					\item[] \texttt{arg1(def=i)}: Situation argument.
					\item[] \texttt{type1(def=\type{et})}: Type of the first argument
					\item[] \texttt{type2(def=\type{s})}: Type of the situation argument
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsritcontrolverbs= \begin{semcalc}\begin{semrule}[ ]\rsritcontrolverbs\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Indirect Interpretation Denotation Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrid{right}{left}[sidenote][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{right}: Right argument.
					\item[] \texttt{left}: Left argument.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{assignment(def=g)}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsrid{Right}{Left}= \begin{semcalc}\begin{semrule}[ ]\rsrid{Right}{Left}\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsridinterpretvar[sidenote][assignment][arg][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{assignment(def=g)}: The assignment function var.
					\item[] \texttt{arg(def=x)}: The argument variable.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsridinterpretvar= \begin{semcalc}\begin{semrule}[ ]\rsridinterpretvar\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsridapp[sidenote][assignment][arg1][arg2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{assignment(def=g)}: The assignment function var.
					\item[] \texttt{arg1(def=\ensuremath{\bm{\alpha}})}: The first argument.
					\item[] \texttt{arg2(def=\ensuremath{\bm{\beta}})}: The second argument.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsridapp= \begin{semcalc}\begin{semrule}[ ]\rsridapp\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsridabs[sidenote][assignment][arg][var][replacement][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{arg(def=\ensuremath{\bm{\alpha}})}: The argument.
					\item[] \texttt{var(def=\textit{x})}: The variable to be replaced.
					\item[] \texttt{replacement(def=\textit{u})}: The variable replacement.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation intension rule.
				\item[] Example: \verb=\rsridabs= \begin{semcalc}\begin{semrule}[ ]\rsridabs\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Quantifier Raising Rules
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrsemvar[sidenote][leftTerm][var][situation][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{leftTerm(def=$\phi$)}: The var. for the left term.
					\item[] \texttt{var(def=\textbf{\textit{x}})}: The variable to be replaced.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrsemvar= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrsemvar\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrabs[sidenote][rightTerm][replacement][situation][assignment][function][original][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{rightTerm(def=$\phi$)}: The var. for the left term.
					\item[] \texttt{replacement(def=\textbf{\textit{x}})}: The variable to be replaced.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{function(def=\textit{f})}: The assignment function var.
					\item[] \texttt{original(def=$\xi$)}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrabsr= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrabs\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrlex[sidenote][leftTerm][rightTerm][replacement][situation][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{leftTerm(def=$\alpha$)}: The left term.
					\item[] \texttt{rightTerm(def=$\beta$)}: The right term.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrlex= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrlex\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrfa[sidenote][leftTerm][rightTerm][rightArgTerm][situation][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{leftTerm(def=$\alpha$)}: The left term.
					\item[] \texttt{rightTerm(def=$\beta$)}: The right term.
					\item[] \texttt{rightArgTerm(def=$\gamma$)}: The right argument term.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrfa= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrfa\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\rsrdeqrtree[sidenote][lambda][leftTerm][rightTerm][replacement][situation][assignment][type][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{lambda(def=\textit{x})}: The lambda head and replacement.
					\item[] \texttt{leftTerm(def=$\psi$)}: The left term.
					\item[] \texttt{rightTerm(def=$\phi$)}: The right term.
					\item[] \texttt{replacement(def=$\xi$)}: The assignment function modification var.
					\item[] \texttt{situation(def=\sblank)}: The situation.
					\item[] \texttt{assignment(def=\textit{g})}: The assignment function var.
					\item[] \texttt{type(def=\typee)}: The type of the lambda head.
					\item[] \texttt{label}: The item label, if blank the label will be R + the current rule index.
				\end{itemizeexamplecommand}
				\item[] Description: Create an entry for a direct interpretation rule in the quantifier raising framework.
				\item[] Example: \verb=\rsrdeqrtree= \begin{semcalc}\begin{semrule}[ ]\rsrdeqrtree\end{semrule}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semrulesyn}
	The \textit{semantic-rule-syn} is an optional environment and is used to list all syntactic rules used for a derivation of a direct or indirect semantic expressions. Each syntactic rule gets automatically label (if used via \verb=\rentry= or predefined syntactical rule) with the following pattern: \\"sem:deri:refNamers:rulecounter". So the first syntactical rule in the second semcalc env. will have the following label: "sem:deri:2:rs:1" assuming that no custom refName has been set.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semrulesyn}[label]
				content...
			\end{semrulesyn}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= in front.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for syntactic rules.
				\item[] New Commands: No
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semlex}
	The \textit{semantic-lexicon} environment is used to list all lexicon entries used for a derivation of a direct or indirect semantic expressions. Each lexicon entry gets automatically label (if used via \verb=\rentry= or predefined lexicon entry) with the following pattern: \\"sem:deri:refName:l:lexcounter". So the first lexicon entry in the second semcalc env. will have the following label: "sem:deri:2:l:1" assuming that no custom refName has been set.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semlex}[label]
				content...
			\end{semlex}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= in front.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for easy listing of semantic lexicon entries.
				\item[] New Commands: Yes
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Commands}
	The \FraGoLi\ package offers the most common semantic lexicon entries for both direct and indirect interpretation based on the accompanying material to an introductory course to linguistic semantics by \textit{Thomas Ede Zimmermann}. All pre-defined lexicon entries can be customized with aspect to variables and lambda heads. General commands for fast rule lexicon creation are also featured. All commands start with sl (semantic lexicon) followed by a categorization into direct (plus intension/extension) or indirect (plus translation/denotation) e.g. \verb=\sldenn= for \\\texttt{semantic-lexicon-direct-extension-properName}. All pre-defined lexicon entries have the option to add a side note. If the package option \texttt{usetypes} is enabled all pre-defined rules will show the type on each lambda head.
	\\Direct Interpretation Lexicon Extension
	\pex\begin{itemizeexamplecommand}
		\item[]
		\begin{lstlisting}[style=B]
		\slde{left}{right}[sidenote][situation][label]
		\end{lstlisting}
		{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
				\item[] \texttt{left}: The object language element
				\item[] \texttt{rightv}: The meta language translation
				\item[] \texttt{sidenote}: Side note text.
				\item[] \texttt{situation(def=\sstar)}: The situation
				\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
			\end{itemizeexamplecommand}
			\item[] Description: General lexicon entry for direct translation of extensions.
			\item[] Example: \verb=\slde{ab}{\e{a} $\cdot$ 10 + \e{b}}= \begin{semcalc}\begin{semlex}[ ]\slde{ab}{\e{a} $\cdot$ 10 + \e{b}}\end{semlex}\end{semcalc}
		}
	\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
		\item[]
		\begin{lstlisting}[style=B]
		\sldei{element}[sidenote][situation][label]
		\end{lstlisting}
		{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
				\item[] \texttt{left}: The object language element
				\item[] \texttt{sidenote}: Side note text.
				\item[] \texttt{situation(def=\sstar)}: The situation
				\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
			\end{itemizeexamplecommand}
			\item[] Description: General lexicon entry for direct translation of extensions with identical graphemes.
			\item[] Example: \verb=\sldei{10}= \begin{semcalc}\begin{semlex}[ ]\sldei{10}\end{semlex}\end{semcalc}
		}
	\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldex{word}[lambdaBody][sidenote][var][situation][type][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var}} \texttt{word} in \sstar}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var(def=x)}: Lambda head variable.
					\item[] \texttt{situation(def=\sstar)}: The situation
					\item[] \texttt{type(def=\type{e})}: The type of the lambda head variable.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for intransitive verbs or adjectives.
				\item[] Example: \verb=\sldex{sleeps}= \begin{semcalc}\begin{semlex}[ ]\sldex{sleeps}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldey{word}[lambdaBody][sidenote][var1][var2][situation][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var1}} \texttt{word} \textit{\texttt{var2}} in \sstar}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=x)}: Inner lambda head variable.
					\item[] \texttt{var2(def=y)}: Outer lambda head variable.
					\item[] \texttt{situation(def=\sstar)}: The situation
					\item[] \texttt{type1(def=\type{e})}: The type of the inner lambda head variable.
					\item[] \texttt{type2(def=\type{e})}: The type of the outer lambda head variable.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for transitive verbs.
				\item[] Example: \verb=\sldey{kills}= \begin{semcalc}\begin{semlex}[ ]\sldey{kills}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldez{word}[lambdaBody][sidenote][var1][var2][var3][situation][type1][type2]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for.
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var1}} \texttt{word} \textit{\texttt{var2}} in \sstar}.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=x)}: Inner lambda head variable.
					\item[] \texttt{var2(def=y)}: Middle lambda head variable.
					\item[] \texttt{var3(def=z)}: Outer lambda head variable.
					\item[] \texttt{situation(def=\sstar)}: The situation.
					\item[] \texttt{type1(def=\type{e})}: The type of the inner lambda head variable.
					\item[] \texttt{type2(def=\type{e})}: The type of the middle and outer lambda head variable.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for ditransitive verbs.
				\item[] Example: \verb=\sldez{shows}= \begin{semcalc}\begin{semlex}[ ]\sldez{shows}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldenn{name}[sidenote][situation][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name to create the lexicon entry for.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=\sstar)}: The situation
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for proper names.
				\item[] Example: \verb=\sldenn{Peter}= \begin{semcalc}\begin{semlex}[ ]\sldenn{Peter}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	A little set of common semantic names is pre-defined like \verb=\sldennpeter=. Those names are \zit{Peter, Maria, Anna, Paul, Eike, Ida, Olaf, Michael, Alina, Marta}. All pre-defined names can have side notes, custom situations and labels. The command syntax would be 
	\\\verb=\sldennpeter[sidenote][situation][label]=.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slden{nominal}[article][sidenote][var][situation][type][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{nominal}: The nominal to create the lexicon entry for.
					\item[] \texttt{article(def=a)}: The article in the lambda boy (will be switched to \textit{ein} if language is set to german). If empty this will also be the case.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var(def=x)}: The lambda head variable
					\item[] \texttt{situation(def=\sstar)}: The situation
					\item[] \texttt{type(def=\type{e})}: The lambda head var type.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for proper names.
				\item[] Example: \verb=\slden{Cat}= \begin{semcalc}\begin{semlex}[ ]\slden{Cat}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	A little set of common semantic nominals is pre-defined like \verb=\sldenman=. Those will fully translate if language is set to \textit{german}. All pre-defined nominals can have side notes, custom lambda heads, situations, types and labels. The command syntax would be 
	\\\verb=\sldenman[sidenote][var][situation][type][label]=.
	\begin{center}
		\begin{minipage}[h][3.5cm][t]{15em}
			\begin{lstlisting}[style=B]
			\sldenman
			\sldenwoman
			\sldenchild
			\sldendog
			\sldencat
			\sldenanimal
			\sldenhouse
			\sldendonkey
			\end{lstlisting}
		\end{minipage}
		\begin{minipage}[h][3.5cm][t]{15em}
			\begin{fgls}
				\ \\
				Mann\\
				Woman\\
				Child\\
				Dog\\
				Cat\\
				Animal\\
				House\\
				Donkey
			\end{fgls}
		\end{minipage}
	\end{center}
	Direct Interpretation Lexicon Intension
	\pex\begin{itemizeexamplecommand}
		\item[]
		\begin{lstlisting}[style=B]
		\sldi{left}{right}[sidenote][label]
		\end{lstlisting}
		{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
				\item[] \texttt{left}: The object language element
				\item[] \texttt{rightv}: The meta language translation
				\item[] \texttt{sidenote}: Side note text.
				\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
			\end{itemizeexamplecommand}
			\item[] Description: General lexicon entry for direct translation of intensions.
			\item[] Example: \verb=\sldi{ab}{\i{a} $\cdot$ 10 + \i{b}}= \begin{semcalc}\begin{semlex}[ ]\sldi{ab}{\i{a} $\cdot$ 10 + \i{b}}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
		\xe
		\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldii{element}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: The object language element
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for direct translation of intension with identical graphemes.
				\item[] Example: \verb=\sldii{10}= \begin{semcalc}\begin{semlex}[ ]\sldii{10}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
		\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldix{word}[lambdaBody][sidenote][var][situation][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var}} \texttt{word} in \texttt{situation}}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var(def=x)}: Lambda head variable.
					\item[] \texttt{situation(def=\sblank)}: The situation
					\item[] \texttt{type1(def=\type{e})}: The type of the lambda head variable.
					\item[] \texttt{type2(def=\type{s})}: The type of the situation lambda head variable (should be used if you want to display the type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for intransitive verbs or adjectives.
				\item[] Example: \verb=\sldix{sleeps}= \begin{semcalc}\begin{semlex}[ ]\sldix{sleeps}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldiy{word}[lambdaBody][sidenote][var1][var2][situation][type1][type2][type3]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var}} \texttt{word} in \texttt{situation}}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var(def=x)}: Lambda head variable.
					\item[] \texttt{var2(def=y)}: Lambda head variable.
					\item[] \texttt{situation(def=\sblank)}: The situation
					\item[] \texttt{type1(def=\type{e})}: The type of the inner lambda head variable.
					\item[] \texttt{type2(def=\type{e})}: The type of the middle lambda head variable.
					\item[] \texttt{type3(def=\type{s})}: The type of the situation lambda head variable (should be used if you want to display the type).
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for intransitive verbs or adjectives.
				\item[] Example: \verb=\sldiy{kills}= \begin{semcalc}\begin{semlex}[ ]\sldiy{kills}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldiz{word}[lambdaBody][sidenote][var1][var2][var3][situation][type1][type2]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{word}: The word to create the lexicon entry for
					\item[] \texttt{lambdaBody}: The lambda body, if empty the  text will be \zit{\textit{\texttt{var}} \texttt{word} in \texttt{situation}}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var(def=x)}: Lambda head variable.
					\item[] \texttt{var2(def=y)}: Lambda head variable.
					\item[] \texttt{var3(def=z)}: Lambda head variable.
					\item[] \texttt{situation(def=\sblank)}: The situation
					\item[] \texttt{type1(def=\type{e})}: The type of the inner middle and second middle lambda head variable.
					\item[] \texttt{type2(def=\type{s})}: The type of the situation lambda head variable (should be used if you want to display the type).
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for intransitive verbs or adjectives.
				\item[] Example: \verb=\sldiz{shows}= \begin{semcalc}\begin{semlex}[ ]\sldiz{shows}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\sldinn{name}[sidenote][situation][type][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name to create the lexicon entry for.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{situation(def=\sblank)}: The situation
					\item[] \texttt{type(def=\type{s})}: The situation type (should be used to display the type)
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry function for proper names.
				\item[] Example: \verb=\sldinn{Peter}= \begin{semcalc}\begin{semlex}[ ]\sldinn{Peter}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Indirect Interpretation Lexicon Translation
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slit{left}{right}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument
					\item[] \texttt{right}: Right argument.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation.
				\item[] Example: \verb=\slit{Left}{Right}= \begin{semcalc}\begin{semlex}[ ]\slit{Left}{Right}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitnn{name}[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect proper name translation.
				\item[] Example: \verb=\slitnn{Peter}= \begin{semcalc}\begin{semlex}[ ]\slitnn{Peter}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	A little set of common semantic names is pre-defined like \verb=\slitnnpeter=. Those names are \zit{Peter, Maria, Anna, Alina, Marta, Paul, Eike, Ida, Olaf, Michael}. All pre-defined names can have side notes, custom situations and labels. The command syntax would be 
	\\\verb=\slitnnpeter[sidenote][situation][label]=.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitf{name}[situation][sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name.
					\item[] \texttt{situation(def=i)}: The situation var.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect function translation.
				\item[] Example: \verb=\slitf{sleeps}= \begin{semcalc}\begin{semlex}[ ]\slitf{sleeps}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitland[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation.
				\item[] Example: \verb=\slitland= \begin{semcalc}\begin{semlex}[ ]\slitland\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlor[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=q)}: First lambda head variable.
					\item[] \texttt{var2(def=p)}: Second lambda head variable.
					\item[] \texttt{type1}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation.
				\item[] Example: \verb=\slitlor= \begin{semcalc}\begin{semlex}[ ]\slitlor\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlno[sidenote][var1][var2][var3][type1][type2][type3][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var2(def=x)}: Bound variable (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier no.
				\item[] Example: \verb=\slitlno= \begin{semcalc}\begin{semlex}[ ]\slitlno\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitloneindef[sidenote][var1][var2][var3][type1][type2][type3][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var3(def=x)}: Bound variable (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier one (indefinite).
				\item[] Example: \verb=\slitloneindef= \begin{semcalc}\begin{semlex}[ ]\slitloneindef\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlonenum[sidenote][var1][var2][var3][var4][type1][type2][type3][type4]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var3(def=x)}: Bound variable outer (existential)
					\item[] \texttt{var4(def=y)}: Bound variable inner (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{type4(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier one (numerical).
				\item[] Example: \verb=\slitlonenum= \begin{semcalc}\begin{semlex}[ ]\slitlonenum\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlevery[sidenote][var1][var2][var3][type1][type2][type3][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var3(def=x)}: Bound variable (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier every.
				\item[] Example: \verb=\slitlevery= \begin{semcalc}\begin{semlex}[ ]\slitlevery\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitlmost[sidenote][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of quantifier most.
				\item[] Example: \verb=\slitlmost= \begin{semcalc}\begin{semlex}[ ]\slitlmost\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitldefarticle[sidenote][var1][var2][var3][var4][type1][type2][type3][type4]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=Q)}: First lambda head variable.
					\item[] \texttt{var2(def=P)}: Second lambda head variable.
					\item[] \texttt{var3(def=x)}: Bound variable outer (existential)
					\item[] \texttt{var4(def=y)}: Bound variable inner (existential)
					\item[] \texttt{type1(def=\type{et})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{et})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{type4(def=\type{e})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of definite article (Russell style).
				\item[] Example: \verb=\slitldefarticle= \begin{semcalc}\begin{semlex}[ ]\slitldefarticle\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slitadox[sidenote][var1][var2][var3][var4][type1][type2][type3][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=p)}: First lambda head variable.
					\item[] \texttt{var2(def=x)}: Second lambda head variable.
					\item[] \texttt{var3(def=j)}: Bound variable outer (existential)
					\item[] \texttt{var4(def=i)}: Bound variable inner (existential)
					\item[] \texttt{type1(def=\type{st})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{e})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{s})}: Bound variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation of Hintikka Semantics. For other perspectives use \verb=\slitaepi= or \verb=\slitabou=.
				\item[] Example: \verb=\slitadox= \begin{semcalc}\begin{semlex}[ ]\slitadox\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\ \\Indirect Interpretation Lexicon Denotation
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slid{left}{right}[sidenote][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{left}: Left argument
					\item[] \texttt{right}: Right argument.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General lexicon entry for indirect translation.
				\item[] Example: \verb=\slid{Left}{Right}[][g]= \begin{semcalc}\begin{semlex}[ ]\slid{Left}{Right}[][g]\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidnn{name}[sidenote][assignment][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{name}: The proper name.
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of a proper name constant.
				\item[] Example: \verb=\slidnn{Peter}= \begin{semcalc}\begin{semlex}[ ]\slidnn{Peter}\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	A little set of common semantic names is pre-defined like \verb=\slidnnpeter=. Those names are \\\zit{Peter, Maria, Anna, Alina, Marta, Paul, Eike, Ida, Olaf, Michael}. All pre-defined names can have side notes, custom assignment functions and labels. The command syntax would be 
	\\\verb=\slidnnpeter[sidenote][assignment][label]=.
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidland[sidenote][var1][var2][assignment][type1][type2][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=v)}: First lambda head variable.
					\item[] \texttt{var2(def=u)}: Second lambda head variable.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{type1(def=\type{t})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{t})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of the logical constant and.
				\item[] Example: \verb=\slidland= \begin{semcalc}\begin{semlex}[ ]\slidland\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidlexists[sidenote][var1][assignment][type1][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=P)}: First lambda head variable.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{type1(def=\type{t})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of the existential quantifier.
				\item[] Example: \verb=\slidlexists= \begin{semcalc}\begin{semlex}[ ]\slidlexists\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidlneg[sidenote][var1][assignment][type1][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=u)}: First lambda head variable.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{type1(def=\type{t})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of the  negation.
				\item[] Example: \verb=\slidlneg= \begin{semcalc}\begin{semlex}[ ]\slidlneg\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidlequal[sidenote][var1][assignment][type1][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=y)}: First lambda head variable.
					\item[] \texttt{var2(def=x)}: Second lambda head variable.
					\item[] \texttt{assignment}: The assignment function.
					\item[] \texttt{type1(def=\type{t})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{t})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{label}: The item label, if blank the label will be L + the current lexicon index.
				\end{itemizeexamplecommand}
				\item[] Description: General interpretation of the  negation.
				\item[] Example: \verb=\slidlequal= \begin{semcalc}\begin{semlex}[ ]\slidlequal\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\pex\begin{itemizeexamplecommand}
			\item[]
			\begin{lstlisting}[style=B]
			\slidadox[sidenote][var1][assignment][type1][label]
			\end{lstlisting}
			{\scriptsize\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{sidenote}: Side note text.
					\item[] \texttt{var1(def=x)}: First lambda head variable.
					\item[] \texttt{var2(def=\szero)}: Second lambda head variable.
					\item[] \texttt{var2(def=\sone)}: Third lambda head variable.
					\item[] \texttt{type1(def=\type{e})}: First lambda head variable type (should be used to display type).
					\item[] \texttt{type2(def=\type{s})}: Second lambda head variable type (should be used to display type).
					\item[] \texttt{type3(def=\type{s})}: Third lambda head variable type (should be used to display type).
					\item[] \texttt{assignment}: The assignment function.
				\end{itemizeexamplecommand}
				\item[] Description: General indirect interpretation of Hintikka Semantics. For other perspectives use \verb=\slidaepi= or \verb=\slidabou=. Text gets automatically translated.
				\item[] Example: \verb=\slidadox= \begin{semcalc}\begin{semlex}[ ]\slidadox\end{semlex}\end{semcalc}
			}
		\end{itemizeexamplecommand}
	\xe
	\subsection{semderi}
	The \textit{semantic-derivation} environment is a specialized version of the \textit{semderivation} env. and is tweaked to work inside a \textit{semcalc} env.
	\pex\begin{itemizeexamplecommand}
			\item[] \begin{lstlisting}[style=B]
			\begin{semderi}[label]
				content...
			\end{semderi}
			\end{lstlisting}
			{\scriptsize
				\item[] Arguments:\begin{itemizeexamplecommand}
					\item[] \texttt{label}: The item label, if blank the label will be the current position of this env. inside the \textit{semcalc}. If you add something, make sure to add \verb=\item= in front.
				\end{itemizeexamplecommand}
				\item[] Description: Env. for easy derivation of direct or indirect semantic expressions.
				\item[] New Commands: Yes
				\item[] Restricted: Yes (semcalc)}
		\end{itemizeexamplecommand}
	\xe
	\subsubsection{Constants}
	This env. has the same new constants as the \textit{semderivation} env.
	\subsubsection{Commands}
	This env. has the same new commands as the \textit{semderivation} env.
	\section{Changelog}
	\begin{itemize}
		\item[1.3.4] 
		\begin{enumerate}
			\item[-] Performance optimization
			\item[-] Changed default \textit{semanticsuperscriptspacing} from narrow to mid.
			\item[-] Change default direct interpretation brackets from stmaryrd to textcomp.
			\item[-] Commands to customize direct interpretation brackets.
			\item[-] Add type shortcuts inside type command.
			\item[-] Reduced usage of bm.
			\item[-] Switched to \href{https://ctan.org/pkg/rainbowbrackets}{rainbowbrackets} package.
			\item[-] Fix incorrectly bold colored parens.
			\item[-] Fix typos
			\item[-] Removed exam env.
		\end{enumerate}
		\item[1.2.3] 
			\begin{enumerate}
				\item[-] Fix wrong argument ordering in indirect translation commands
			\end{enumerate}
		\item[1.2.2] 
			\begin{enumerate}
				\item[-] Add degree semantics support.
				\item[-] Add traces with spaces.
				\item[-] Add new commands for semantic lexicon entries.
				\item[-] Add typenestingstyle (credits to \textit{C\'{e}cile Meier})
				\item[-] Add new pre defined lambda heads.
				\item[-] Add commands to change package settings mid document.
				\item[-] Add basic brackets command for \textit{cps} prevention and bold mode.
				\item[-] Add type shortcuts for fgls env.
				\item[-] Add formatting options for types, situations and direct/indirect superscripts.
				\item[-] Add lambda headers with quantifiers for fgls env.
				\item[-] Fix fglsem command with regard to line breaks. Adding varwidth dependency for that.
				\item[-] Fix some pre-defined lambda heads not being bold in bold mode.
				\item[-] Fix spacing on lambda heads with visible types in upper mode
				\item[-] Fix spacing on derivation steps
			\end{enumerate}
		\item[1.1.1] 
			\begin{enumerate}
				\item[-] Fix missing package dependency.
				\item[-] Fix text overline overriding uuline internal length.
				\item[-] Fix parentheses on lambda quantifier heads being bold in non bold mode.
				\item[-] Add lambdaheadstyle package option.
				\item[-] Add new function framework.
				\item[-] Add new logic commands.
				\item[-] Add new logic constants.
				\item[-] Add new relation constants.
				\item[-] Add new quantifier commands.
				\item[-] Extend set command.
			\end{enumerate}
		\item[1.0.0] 
		\begin{enumerate}
			\item[-] Initial release.
		\end{enumerate}
		\item[0.2.2] 
		\begin{enumerate}
			\item[-] Add option to set default the default situation in the fgls, semrule, semcalc and semderivation env.
			\item[-] Add current situation command and current derivation ref command.
			\item[-] Automatic labels for all semcalc resources and for all derivation steps.
			\item[-] Add rules from the Quantifier Raising Script by Dr. C\'{e}cile Meier.
			\item[-] Add sarrow command.
			\item[-] Add semrulesyn env.
			\item[-] Add semtreesyn and semtreesem env.
			\item[-] Add semlang env.
			\item[-] Add language builder command to semlang env.
			\item[-] Add traces
		\end{enumerate}
		\item[0.1.2] 
		\begin{enumerate}
			\item[-] Add semtree environment.
			\item[-] Fixed derivation step counter.
			\item[-] Fixed various documentation bugs.
		\end{enumerate}
		\item[0.0.1] 
		\begin{enumerate}
			\item[-] First build.
		\end{enumerate}
	\end{itemize}
\end{document}