+\subsubsection{Compatible type and composite type}
+Two types have compatibility if their types are the same.
+
+All declarations that refer to the same object or function shall have compatibility; otherwise, the behavior is undefined.
+
+A composite type can be constructed from two types that are compatible; it is a type that is compatible with both of the two types and satisfies the following conditions:
+\begin{enumerate}
+ \item If one type is a function type with a paramater type list (function prototype), the composite type is a function prototype with the parameter type list.
+ \item If both types are function types with parameter type lists, the type of each parameter in the composite parameter type list is the composite type of the corresponding parameters.
+\end{enumerate}
+
+\subsection{Conversions}
+\subsubsection{Other operands}
+\paragraph{Lvalues, arrays, and function designators}
+An lvalue is an expression with an object type or an incomplete type other than void; if an lvalue does not designate an object when it is evaluated, the behavior is undefined. When an object is said to have a particular type, the type is specified by the lvalue used to designated said object. A modifiable lvalue is an lvalue that does not have an array type, does not have a const-qualified type and does not have an incomplete type.
+
+A function designator is an expression that has function type. A function designator with type "function returning type" is converted to an expression that has type "pointer to function returning type".
+
+\paragraph{void}
+The (nonexistent) value of a void expression (an expression that has type void) shall not be used in any way, and implicit or explicit conversions (except to void) shall not be applied to any such expression. If an expression of a type not void is evaluated as a void expression, its value or designator shall be discarded. (A void expression is evaluated only for its side effects.)
+
+\subsection{Lexical elements}
+\subsubsection{Keywords}