Diff [c84dd616ea09c9d1bd0ef0c0fba904ff70c4d83d:0b0a285cb86eb63d47d96868ae2d0f99f753448c] for / – Cforall

doc/theses/colby_parsons_MMAth/Makefile

-              rc84dd61
+              r0b0a285
         figures/nasus_Channel_Contention \
         figures/pyke_Channel_Contention \
-        figures/pyke_Future \
-        figures/nasus_Future \
-        figures/pyke_Contend_2 \
-        figures/pyke_Contend_4 \
-        figures/pyke_Contend_8 \
-        figures/pyke_Spin_2 \
-        figures/pyke_Spin_4 \
-        figures/pyke_Spin_8 \
-        figures/nasus_Contend_2 \
-        figures/nasus_Contend_4 \
-        figures/nasus_Contend_8 \
-        figures/nasus_Spin_2 \
-        figures/nasus_Spin_4 \
-        figures/nasus_Spin_8 \
+}

doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/balance.cfa

-              rc84dd61
+              r0b0a285
 allocation receive( d_actor & this, start_msg & msg ) with( this ) {
     for ( i; Set ) {
         *actor_arr[i + gstart] | shared_msg;
+        *actor_arr[i + gstart] << shared_msg;
+    }
     return Nodelete;
 …
     if ( recs % Batch == 0 ) {
         for ( i; Batch ) {
             *actor_arr[gstart + sends % Set] | shared_msg;
+            *actor_arr[gstart + sends % Set] << shared_msg;
             sends += 1;
+        }
 …
     #ifndef MULTI
         for ( i; qpw )
                 *actors[i * ActorsPerQueue] | start_send;
+                *actors[i * ActorsPerQueue] << start_send;
     #else
     for ( i; qpw * ActorProcs ) {
                 *actors[i * ActorsPerQueue] | start_send;
+                *actors[i * ActorsPerQueue] << start_send;
+    }
     #endif
     for ( i; FillActors )
         *filler_actors[i] | shared_msg;
+        *filler_actors[i] << shared_msg;
     stop_actor_system();

doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/dynamic.cfa

-              rc84dd61
+              r0b0a285
     derived_actor * d_actor = malloc();
     (*d_actor){};
     *d_actor | *d_msg;
+    *d_actor << *d_msg;
     return Delete;
+}
 …
     derived_actor * d_actor = malloc();
     (*d_actor){};
     *d_actor | *d_msg;
+    *d_actor << *d_msg;

doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/executor.cfa

-              rc84dd61
+              r0b0a285
     if ( recs % Batch == 0 ) {
         for ( i; Batch ) {
             gstart[sends % Set] | shared_msg;
+            gstart[sends % Set] << shared_msg;
             sends += 1;
+        }
 …
         for ( i; Actors ) {
                 actors[i] | shared_msg;
+                actors[i] << shared_msg;
         } // for

doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/matrix.cfa

rc84dd61	r0b0a285
103	103
104	104	for ( unsigned int r = 0; r < xr; r += 1 ) {
105		actors[r] \| messages[r];
	105	actors[r] << messages[r];
106	106	} // for
107	107

doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/repeat.cfa

-              rc84dd61
+              r0b0a285
 Client * cl;
 allocation receive( Server & this, IntMsg & msg ) { msg.val = 7; *cl | msg; return Nodelete; }
 allocation receive( Server & this, CharMsg & msg ) { msg.val = 'x'; *cl | msg; return Nodelete; }
+allocation receive( Server & this, IntMsg & msg ) { msg.val = 7; *cl << msg; return Nodelete; }
+allocation receive( Server & this, CharMsg & msg ) { msg.val = 'x'; *cl << msg; return Nodelete; }
 allocation receive( Server & this, StateMsg & msg ) { return Finished; }
 void terminateServers( Client & this ) with(this) {
     for ( i; Messages ) {
         servers[i] | stateMsg;
+        servers[i] << stateMsg;
     } // for
+}
 …
     if ( times == Times ) { terminateServers( this ); return Finished; }
     results = 0;
     this | stateMsg;
+    this << stateMsg;
     return Nodelete;
+}
 …
 allocation receive( Client & this, StateMsg & msg ) with(this) {
     for ( i; Messages ) {
         servers[i] | intmsg[i];
         servers[i] | charmsg[i];
+        servers[i] << intmsg[i];
+        servers[i] << charmsg[i];
+    }
     return Nodelete;
 …
     Client client;
     cl = &client;
     client | stateMsg;
+    client << stateMsg;
     stop_actor_system();

doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/static.cfa

-              rc84dd61
+              r0b0a285
+    }
     msg.cnt++;
     receiver | msg;
+    receiver << msg;
     return Nodelete;
+}
 …
     derived_actor actor;
     actor | msg;
+    actor << msg;
     stop_actor_system();

doc/theses/colby_parsons_MMAth/benchmarks/actors/plotData.py

rc84dd61	r0b0a285
166	166	for idx, arr in enumerate(data):
167	167	plt.errorbar( procs, arr, [bars[idx][0], bars[idx][1]], capsize=2, marker=next(marker) )
168		~~marker = itertools.cycle(('o', 's', 'D', 'x', 'p', '^', 'h', '*', 'v' ))~~
169	168	if currBench == Bench.Executor or currBench == Bench.Matrix or currBench == Bench.Balance_One or currBench == Bench.Repeat:
170	169	plt.yscale("log")

doc/theses/colby_parsons_MMAth/benchmarks/channels/plotData.py

rc84dd61	r0b0a285
130	130	for idx, arr in enumerate(data):
131	131	plt.errorbar( procs, arr, [bars[idx][0], bars[idx][1]], capsize=2, marker=next(marker) )
132		~~marker = itertools.cycle(('o', 's', 'D', 'x', 'p', '^', 'h', '*', 'v' ))~~
	132
133	133	plt.yscale("log")
134	134	# plt.ylim(1, None)

doc/theses/colby_parsons_MMAth/benchmarks/mutex_stmt/plotData.py

rc84dd61	r0b0a285
103	103	for idx, arr in enumerate(data):
104	104	plt.errorbar( procs, arr, [bars[idx][0], bars[idx][1]], capsize=2, marker=next(marker) )
105		~~marker = itertools.cycle(('o', 's', 'D', 'x', 'p', '^', 'h', '*', 'v' ))~~
106	105	plt.yscale("log")
107	106	plt.xticks(procs)

doc/theses/colby_parsons_MMAth/glossary.tex

-              rc84dd61
+              r0b0a285
 \newabbreviation{toctou}{TOCTOU}{\Newterm{time-of-check to time-of-use}}
+\newglossaryentry{actor}{
+\newglossaryentry{actor}
+{
 name=actor,
 description={A basic unit of an actor system that can store local state and send messages to other actors.}
+}
 \newglossaryentry{gulp}{
+name={gulp},
 first={\Newterm{gulp}},
+\newglossaryentry{gulp}
+{
+name=gulp,
 description={Move the contents of message queue to a local queue of the executor thread using a single atomic instruction.}
+}
+\newglossaryentry{impl_concurrency}{
+\newglossaryentry{impl_concurrency}
+{
 name=implicit concurrency,
-first={\Newterm{implicit concurrency}},
 description={A class of concurrency features that abstract away explicit thread synchronization and mutual exclusion.}
+}
+\newglossaryentry{actor_model}{
+\newglossaryentry{actor_model}
+{
 name=actor model,
-first={\Newterm{actor model}},
 description={A concurrent computation model, where tasks are broken into units of work that are distributed to actors in the form of messages.}
+}
+\newglossaryentry{actor_system}{
+\newglossaryentry{actor_system}
+{
 name=actor system,
-first={\Newterm{actor system}},
 description={An implementation of the actor model.}
+}
+\newglossaryentry{synch_multiplex}{
+\newglossaryentry{synch_multiplex}
+{
 name=synchronous multiplexing,
-first={\Newterm{synchronous multiplexing}},
 description={synchronization on some subset of a set of resources.}
+}

doc/theses/colby_parsons_MMAth/local.bib

-              rc84dd61
+              r0b0a285
+}
-@misc{go:sched,
-  author = "The Go Programming Language",
-  title = "src/runtime/proc.go",
-  howpublished = {\href{https://go.dev/src/runtime/proc.go}},
-  note = "[Online; accessed 23-May-2023]"
+}
 @misc{go:selectref,
   author = "The Go Programming Language Specification",

doc/theses/colby_parsons_MMAth/text/actors.tex

-              rc84dd61
+              r0b0a285
 % C_TODO: add citations throughout chapter
 Actors are an indirect concurrent feature that abstracts threading away from a programmer, and instead provides \gls{actor}s and messages as building blocks for concurrency, where message passing means there is no shared data to protect, making actors amenable in a distributed environment.
 Actors are another message passing concurrency feature, similar to channels but with more abstraction, and are in the realm of \gls{impl_concurrency}, where programmers write concurrent code without dealing with explicit thread creation or interaction.
+Actors are another message passing concurrency feature, similar to channels but with more abstraction, and are in the realm of \gls{impl_concurrency}, where programmers write concurrent code without dealing with explicit thread create or interaction.
 The study of actors can be broken into two concepts, the \gls{actor_model}, which describes the model of computation and the \gls{actor_system}, which refers to the implementation of the model.
 Before discussing \CFA's actor system in detail, it is important to first describe the actor model, and the classic approach to implementing an actor system.
 …
 An actor is executed by an underlying \Newterm{executor} (kernel thread-pool) that fairly invokes each actor, where an actor invocation processes one or more messages from its mailbox.
 The default number of executor threads is often proportional to the number of computer cores to achieve good performance.
 An executor is often tunable with respect to the number of kernel threads and its scheduling algorithm, which optimize for specific actor applications and workloads \see{end of Section~\ref{s:CFAActor}}.
 \subsection{Classic Actor System}
+An executor is often tunable with respect to the number of kernel threads and its scheduling algorithm, which optimize for specific actor applications and workloads \see{end of Section~\ref{s:CFAActorSyntax}}.
+\section{Classic Actor System}
 An implementation of the actor model with a community of actors is called an actor system.
 Actor systems largely follow the actor model, but can differ in some ways.
 …
 \end{figure}
 \subsection{\CFA Actor System}
+\section{\CFA Actors}
 Figure~\ref{f:standard_actor} shows an actor system designed as \Newterm{actor-centric}, where a set of actors are scheduled and run on underlying executor threads~\cite{CAF,Akka,ProtoActor}.
 The simplest design has a single global queue of actors accessed by the executor threads, but this approach results in high contention as both ends of the queue by the executor threads.
 …
 \end{enumerate}
 \section{\CFA Actor}\label{s:CFAActor}
+\section{\CFA Actor Syntax}\label{s:CFAActorSyntax}
 \CFA is not an object oriented language and it does not have \gls{rtti}.
 As such, all message sends and receives among actors can only occur using static type-matching, as in Typed-Akka~\cite{AkkaTyped}.
 …
 // messages
 struct str_msg {
+        @inline message;@                                               $\C{// Plan-9 C nominal inheritance}$
         char str[12];
-        @inline message;@                                               $\C{// Plan-9 C inheritance}$
 };
 void ?{}( str_msg & this, char * str ) { strcpy( this.str, str ); }  $\C{// constructor}$
 struct int_msg {
+        @inline message;@                                               $\C{// Plan-9 C nominal inheritance}$
         int i;
-        @inline message;@                                               $\C{// Plan-9 C inheritance}$
 };
+void ?{}( int_msg & this, int i ) { this.i = i; }       $\C{// constructor}$
 // behaviours
 allocation receive( my_actor &, @str_msg & msg@ ) with(msg) {
         sout | "string message \"" | str | "\"";
+allocation receive( my_actor &, @str_msg & msg@ ) {
+        sout | "string message \"" | msg.str | "\"";
         return Nodelete;                                                $\C{// actor not finished}$
+}
 allocation receive( my_actor &, @int_msg & msg@ ) with(msg) {
         sout | "integer message" | i;
+allocation receive( my_actor &, @int_msg & msg@ ) {
+        sout | "integer message" | msg.i;
         return Nodelete;                                                $\C{// actor not finished}$
+}
 int main() {
+        start_actor_system();                                   $\C{// sets up executor}$
+        my_actor actor;                                                 $\C{// default constructor call}$
         str_msg str_msg{ "Hello World" };               $\C{// constructor call}$
         int_msg int_msg{ 42 };                                  $\C{// constructor call}$
+        start_actor_system();                                   $\C{// sets up executor}$
+        my_actor actor;                                                 $\C{// default constructor call}$
+        @actor | str_msg | int_msg;@                    $\C{// cascade sends}$
+        @actor | int_msg;@                                              $\C{// send}$
+        @actor | finished_msg;@                                 $\C{// send => terminate actor (deallocation deferred)}$
+        @actor << str_msg << int_msg;@                  $\C{// cascade sends}$
+        @actor << int_msg;@                                             $\C{// send}$
+        @actor << finished_msg;@                                $\C{// send => terminate actor (deallocation deferred)}$
         stop_actor_system();                                    $\C{// waits until actors finish}\CRT$
 } // deallocate int_msg, str_msg, actor
 \end{cfa}
 \caption{\CFA Actor Syntax}
 \label{f:CFAActor}
 \end{figure}
 Figure~\ref{f:CFAActor} shows a complete \CFA actor example starting with the actor type @my_actor@ created by defining a @struct@ that inherits from the base @actor@ @struct@ via the @inline@ keyword.
 This inheritance style is the Plan-9 C-style inheritance discussed in Section~\ref{s:Inheritance}.
+\label{f:CFAActorSyntax}
+\end{figure}
+Figure~\ref{f:CFAActorSyntax} shows a complete \CFA actor example starting with the actor type @my_actor@ created by defining a @struct@ that inherits from the base @actor@ @struct@ via the @inline@ keyword.
+This inheritance style is the Plan-9 C-style nominal inheritance discussed in Section~\ref{s:Inheritance}.
 Similarly, the message types @str_msg@ and @int_msg@ are created by defining a @struct@ that inherits from the base @message@ @struct@ via the @inline@ keyword.
+Only @str_msg@ needs a constructor to copy the C string;
+@int_msg@ is initialized using its \CFA auto-generated constructors.
+Both message types have constructors to set the message value.
 There are two matching @receive@ (behaviour) routines that process the corresponding typed messages.
+Both @receive@ routines use a @with@ clause so message fields are not qualified and return @Nodelete@ indicating the actor is not finished.
+Also, all messages are marked with @Nodelete@ as their default allocation state.
+The program main begins by creating two messages on the stack.
+Then the executor system is started by calling @start_actor_system@.
+Now an actor is created on the stack and four messages are sent it using operator @?|?@.
+The last message is the builtin @finish_msg@, which returns @Finished@ to an executor thread, causing it to removes the actor from the actor system \see{Section~\ref{s:ActorBehaviours}}.
+The call to @stop_actor_system@ blocks the program main until all actors are finished and removed from the actor system.
+The program main ends by deleting the actor and two messages from the stack.
+The program main begins by calling @start_actor_system@ to start the actor implementation, including executor threads to run the actors.
+An actor and two messages are created on the stack, and four messages are sent to the actor using operator @<<@.
+The last message is the builtin @finish_msg@, which returns @Finished@ to an executor thread, which removes the actor from the actor system \see{Section~\ref{s:ActorBehaviours}}.
+The call to @stop_actor_system@ blocks program main until all actors are finished and removed from the actor system.
+The program main ends by deleting the actor and messages from the stack.
 The output for the program is:
 \begin{cfa}
 …
 Note, it is safe to construct an actor or message with a status other than @Nodelete@, since the executor only examines the allocation action after a behaviour returns.
-\subsection{Actor Envelopes}\label{s:envelope}
-As stated, each message, regardless of where it is allocated, can be sent to an arbitrary number of actors, and hence, appear on an arbitrary number of message queues.
-Because a C program manages message lifetime, messages cannot be copied for each send, otherwise who manages the copies.
-Therefore, it up to the actor program to manage message life-time across receives.
-However, for a message to appear on multiple message queues, it needs an arbitrary number of associated destination behaviours.
-Hence, there is the concept of an envelop, which is dynamically allocated on each send, that wraps a message with any extra implementation fields needed to persist between send and receive.
-Managing the envelop is straightforward because it is created at the send and deleted after the receive, \ie there is 1:1 relationship for an envelop and a many to one relationship for a message.
-% In actor systems, messages are sent and received by actors.
-% When a actor receives a message it executes its behaviour that is associated with that message type.
-% However the unit of work that stores the message, the receiving actor's address, and other pertinent information needs to persist between send and the receive.
-% Furthermore the unit of work needs to be able to be stored in some fashion, usually in a queue, until it is executed by an actor.
-% All these requirements are fulfilled by a construct called an envelope.
-% The envelope wraps up the unit of work and also stores any information needed by data structures such as link fields.
-% One may ask, "Could the link fields and other information be stored in the message?".
-% This is a good question to ask since messages also need to have a lifetime that persists beyond the work it delivers.
-% However, if one were to use messages as envelopes then a message would not be able to be sent to multiple actors at a time.
-% Therefore this approach would just push the allocation into another location, and require the user to dynamically allocate a message for every send, or require careful ordering to allow for message reuse.
 \subsection{Actor System}\label{s:ActorSystem}
 The calls to @start_actor_system@, and @stop_actor_system@ mark the start and end of a \CFA actor system.
 …
 All actors must be created \emph{after} calling @start_actor_system@ so the executor can keep track of the number of actors that have entered the system but not yet terminated.
+% All message sends are done using the left-shift operator, @<<@, similar to the syntax of \CC's stream output.
+% \begin{cfa}
+% allocation ?<<?( my_actor & receiver, my_msg & msg )
+% \end{cfa}
+% Notice this signature is the same as the @receive@ routine, which is no coincidence.
+% The \CFA compiler generates a @?<<?@ routine definition and forward declaration for each @receive@ routine that has the appropriate signature.
+% The generated routine packages the message and actor in an \hyperref[s:envelope]{envelope} and adds it to the executor's queues via an executor routine.
+% As part of packaging the envelope, the @?<<?@ routine sets a routine pointer in the envelope to point to the appropriate receive routine for given actor and message types.
 \subsection{Actor Send}\label{s:ActorSend}
+All message sends are done using the vertical-bar (bit-or) operator, @?|?@, similar to the syntax of the \CFA stream I/O.
+Hence, programmers must write a matching @?|?@ routine for each @receive@ routine, which is awkward and generates a maintenance problem that must be solved.
+\CFA's current best approach for creating a generic @?|?@ routine requires users to create routines for their actor and message types that access the base type.
+Since these routines are not complex, they can be generated using macros that are used to annotate the user-defined actor and message types.
+This approach is used in \CFA's intrusive list data structure.
+This is not much better than asking users to write the @?|?@ routine themselves in terms of maintenance, since the user needs to remember the boilerplate macro annotation.
+All message sends are done using the left-shift operator, @<<@, similar to the syntax of \CC's stream output.
 As stated, \CFA does not have named inheritance with RTTI.
 \CFA does have a preliminary form of virtual routines, but it is not mature enough for use in this work.
 Virtuals would provide a mechanism to write a single generic @?|?@ routine taking a base actor and message type, that would dynamically select the @receive@ routine from the actor argument.
+Note, virtuals are not needed for the send; Plan-9 inheritance is sufficient because only the inherited fields are needed during the message send (only upcasting is needed).
 Therefore, a template-like approach was chosen, where the compiler generates a matching @?|?@ routine for each @receive@ routine it finds with the correct actor/message type-signature.
 This approach requires no annotation or additional code to be written by users, thus it resolves the maintenance problem.
+Therefore, there is no mechanism to write a generic @<<@ routine taking a base actor and message type, and then dynamically selecting the @receive@ routine from the actor argument.
+(For messages, the Plan-9 inheritance is sufficient because only the inherited fields are needed during the message send.)
+Hence, programmers must write a matching @<<@ routine for each @receive@ routine, which is awkward and generates a maintenance problem.
+Therefore, I chose to use a template-like approach, where the compiler generates a matching @<<@ routine for each @receive@ routine it finds with an actor/message type-signature.
+Then, \CFA uses the type from the left-hand side of an assignment to select the matching receive routine.
 (When the \CFA virtual routines mature, it should be possible to seamlessly transition to it from the template approach.)
+Figure~\ref{f:send_gen} shows the generated send routine for the @int_msg@ receive in Figure~\ref{f:CFAActor}.
+Operator @?|?@ has the same parameter signature as the corresponding @receive@ routine and returns an @actor@ so the operator can be cascaded.
+The routine sets @rec_fn@ to the matching @receive@ routine using the left-hand type to perform the selection.
+Then the routine packages the base and derived actor and message and actor, along with the receive routine into an \hyperref[s:envelope]{envelope}.
+Finally, the envelop is added to the executor queue designated by the actor using the executor routine @send@.
+% Funneling all message sends through a single @allocation ?<<?(actor &, message &)@ routine is not feasible since the type of the actor and message would be erased, making it impossible to acquire a pointer to the correct @receive@.
+% As such a @?<<?@ routine per @receive@ provides type information needed to write the correct "address" on the envelope.
+% The left-shift operator routines are generated by the compiler.
+An example of a receive routine and its corresponding generated operator routine is shown in Figure~\ref{f:actor_gen}.
+Notice the parameter signature of @?<<?@ is the same as the @receive@ routine.
+A @?<<?@ routine is generated per @receive@ routine with a matching signature.
+The @?<<?@ routine packages the message and actor in an \hyperref[s:envelope]{envelope} and adds it to the executor's queues via the executor routine @send@.
+The envelope is conceptually "addressed" to a behaviour, which is stored in the envelope as a function pointer to a @receive@ routine.
+The @?<<?@ routines ensure that messages are sent to the right address, \ie sent to the right @receive@ routine based on actor and message type.
 \begin{figure}
 \begin{cfa}
+$\LstCommentStyle{// from Figure~\ref{f:CFAActor}}$
+struct my_actor { inline actor; };                                              $\C[3.75in]{// actor}$
+struct int_msg { inline message; int i; };                              $\C{// message}$
+allocation receive( @my_actor &, int_msg & msg@ ) {...} $\C{// receiver}$
+// compiler generated send operator
+typedef allocation (*receive_t)( actor &, message & );
+actor & ?|?( @my_actor & receiver, int_msg & msg@ ) {
+        allocation (*rec_fn)( my_actor &, int_msg & ) = @receive@; // deduce receive routine
+        request req{ &receiver, (actor *)&receiver, &msg, (message *)&msg, (receive_t)rec_fn };
+        send( receiver, req );                                                          $\C{// queue message for execution}\CRT$
+$\LstCommentStyle{// from Figure~\ref{f:CFAActorSyntax}}$
+struct my_actor { inline actor; };                                      $\C[3.5in]{// actor}$
+struct int_msg { inline message; int i; };                      $\C{// message}$
+void ?{}( int_msg & this, int i ) { this.i = i; }       $\C{// constructor}$
+allocation receive( @my_actor &, int_msg & msg@ ) {     $\C{// receiver}$
+        sout | "integer message" | msg.i;
+        return Nodelete;
+}
+// compiler generated operator
+#define RECEIVER( A, M ) (allocation (*)(actor &, message &))(allocation (*)( A &, M & ))receive
+my_actor & ?<<?( @my_actor & receiver, int_msg & msg@ ) {
+        send( receiver, (request){ &receiver, &msg, RECEIVER( my_actor, int_msg ) } );
         return receiver;
+}
 \end{cfa}
 \caption{Generated Send Operator}
+\label{f:send_gen}
+\end{figure}
+\subsection{Actor Termination}\label{s:ActorTerm}
+During a message send, the receiving actor and message being sent are stored via pointers in the envelope.
+These pointers have the base actor and message types, so type information of the actor and message is lost and then recovered later when the typed receive routine is called.
+After the receive routine is done, the executor must clean up the actor and message according to their allocation status.
+If the allocation status is @Delete@ or @Destroy@, the appropriate destructor must be called by the executor.
+This poses a problem; the correct type of the actor or message is not available to the executor, but it needs to call the right destructor!
+This requires downcasting from the base type to derived type, which requires a virtual system.
+Thus, a rudimentary destructor-only virtual system was added to \CFA as part of this work.
+This virtual system is used via Plan-9 inheritance of the @virtual_dtor@ type, shown in Figure~\ref{f:VirtDtor}.
+The @virtual_dtor@ type maintains a pointer to the start of the object, and a pointer to the correct destructor.
+When a type inherits the @virtual_dtor@ type, the compiler adds code to its destructor to make sure that any destructor calls along this segment of the inheritance tree is called are intercepted, and restart at the appropriate destructor for that object.
+\begin{figure}
+\begin{cfa}
+struct base_type { inline virtual_dtor; };
+struct intermediate_type { inline base_type; };
+struct derived_type { inline intermediate_type; };
+int main() {
+    derived_type d1, d2, d3;
+    intermediate_type & i = d2;
+    base_type & b = d3;
+    // these will call the destructors in the correct order
+    ^d1{}; ^i{}; ^b{};
+}
+\end{cfa}
+\caption{\CFA Virtual Destructor}
+\label{f:VirtDtor}
+\end{figure}
+This virtual destructor system was built for this work, but is general and can be used in any type in \CFA.
+Actors and messages opt into this system by inheriting the @virtual_dtor@ type, which allows the executor to call the right destructor without knowing the derived actor or message type.
+Figure~\ref{f:ConvenienceMessages} shows three builtin convenience messages and receive routines used to terminate actors, depending on how an actor is allocated: @Delete@, @Destroy@ or @Finished@.
+For example, in Figure~\ref{f:CFAActor}, the builtin @finished_msg@ message and receive are used to terminate the actor because the actor is allocated on the stack, so no deallocation actions are performed by the executor.
+\begin{figure}
+\begin{cfa}
+message __base_msg_finished $@$= { .allocation_ : Finished }; // no auto-gen constructors
+struct __delete_msg_t { inline message; } delete_msg = __base_msg_finished;
+struct __destroy_msg_t { inline message; } destroy_msg = __base_msg_finished;
+struct __finished_msg_t { inline message; } finished_msg = __base_msg_finished;
+allocation receive( actor & this, __delete_msg_t & msg ) { return Delete; }
+allocation receive( actor & this, __destroy_msg_t & msg ) { return Destroy; }
+allocation receive( actor & this, __finished_msg_t & msg ) { return Finished; }
+\end{cfa}
+\caption{Builtin Convenience Messages}
+\label{f:ConvenienceMessages}
+\label{f:actor_gen}
 \end{figure}
 …
 The goal is to achieve better performance and scalability for certain kinds of actor applications by reducing executor locking.
 Note, lock-free queues do not help because busy waiting on any atomic instruction is the source of the slowdown whether it is a lock or lock-free.
+Work steal now becomes queue stealing, where an entire actor/message queue is stolen, which trivially preserves message ordering in a queue \see{Section~\ref{s:steal}}.
 \begin{figure}
 …
 Each executor thread iterates over its own message queues until it finds one with messages.
+At this point, the executor thread atomically \gls{gulp}s the queue, meaning it moves the contents of message queue to a local queue of the executor thread using a single atomic instruction.
+At this point, the executor thread atomically \gls{gulp}s the queue, meaning move the contents of message queue to a local queue of the executor thread using a single atomic instruction.
+This step allows the executor threads to process the local queue without any atomics until the next gulp, while other executor threads are adding in parallel to the end of one of the message queues.
+In detail, an executor thread performs a test-and-gulp, non-atomically checking if a queue is non-empty before gulping it.
+If a test fails during a message add, the worst-case is cycling through all the message queues.
+However, the gain is minimizing costly lock acquisitions.
 An example of the queue gulping operation is shown in the right side of Figure \ref{f:gulp}, where a executor threads gulps queue 0 and begins to process it locally.
+This step allows an executor thread to process the local queue without any atomics until the next gulp.
+Other executor threads can continue adding to the ends of executor thread's message queues.
+In detail, an executor thread performs a test-and-gulp, non-atomically checking if a queue is non-empty, before attempting to gulp it.
+If an executor misses an non-empty queue due to a race, it eventually finds the queue after cycling through its message queues.
+This approach minimizes costly lock acquisitions.
+Processing a local queue involves: removing a unit of work from the queue, dereferencing the actor pointed-to by the work-unit, running the actor's behaviour on the work-unit message, examining the returned allocation status from the @receive@ routine for the actor and internal status in the delivered message, and taking the appropriate actions.
+Processing a local queue involves removing a unit of work from the queue and executing it.
 Since all messages to a given actor are in the same queue, this guarantees atomicity across behaviours of that actor since it can only execute on one thread at a time.
+As each actor is created or terminated by an executor thread, it increments/decrements a global counter.
+When an executor decrements the counter to zero, it sets a global boolean variable that is checked by each executor thread when it has no work.
+Once a executor threads sees the flag is set it stops running.
+After all executors stop, the actor system shutdown is complete.
+After running a behaviour, the executor thread examines the returned allocation status from the @receive@ routine for the actor and internal status in the delivered message, and takes the appropriate action.
+Once all actors have marked themselves as being finished the executor initiates shutdown by inserting a sentinel value into the message queues.
+Once a executor threads sees a sentinel it stops running.
+After all executors stop running the actor system shutdown is complete.
+\section{Envelopes}\label{s:envelope}
+As stated, each message, regardless of where it is allocated, can be sent to an arbitrary number of actors, and hence, appear on an arbitrary number of message queues.
+Because a C program manages message lifetime, messages cannot be copied for each send, otherwise who manages the copies.
+Therefore, it up to the actor program to manage message life-time across receives.
+However, for a message to appear on multiple message queues, it needs an arbitrary number of link fields.
+Hence, there is the concept of an envelop, which is dynamically allocated on each send, that wraps a message with any extra implementation fields needed to persist between send and receive.
+Managing the envelop is straightforward because it is created at the send and deleted after the receive, \ie there is 1:1 relationship for an envelop and a many to one relationship for a message.
+% In actor systems, messages are sent and received by actors.
+% When a actor receives a message it executes its behaviour that is associated with that message type.
+% However the unit of work that stores the message, the receiving actor's address, and other pertinent information needs to persist between send and the receive.
+% Furthermore the unit of work needs to be able to be stored in some fashion, usually in a queue, until it is executed by an actor.
+% All these requirements are fulfilled by a construct called an envelope.
+% The envelope wraps up the unit of work and also stores any information needed by data structures such as link fields.
+% One may ask, "Could the link fields and other information be stored in the message?".
+% This is a good question to ask since messages also need to have a lifetime that persists beyond the work it delivers.
+% However, if one were to use messages as envelopes then a message would not be able to be sent to multiple actors at a time.
+% Therefore this approach would just push the allocation into another location, and require the user to dynamically allocate a message for every send, or require careful ordering to allow for message reuse.
+Unfortunately, this frequent allocation of envelopes for each send results in heavy contention on the memory allocator.
+As such, a way to alleviate contention on the memory allocator would result in a performance improvement.
+Contention is reduced using a novel data structure, called a \Newterm{copy queue}.
 \subsection{Copy Queue}\label{s:copyQueue}
-Unfortunately, the frequent allocation of envelopes for each send results in heavy contention on the memory allocator.
-This contention is reduced using a novel data structure, called a \Newterm{copy queue}.
 The copy queue is a thin layer over a dynamically sized array that is designed with the envelope use case in mind.
 A copy queue supports the typical queue operations of push/pop but in a different way from a typical array-based queue.
 The copy queue is designed to take advantage of the \gls{gulp}ing pattern, giving an amortized runtime cost for each push/pop operation of $O(1)$.
+A copy queue supports the typical queue operations of push/pop but in a different way than a typical array based queue.
+The copy queue is designed to take advantage of the \gls{gulp}ing pattern.
+As such, the amortized runtime cost of each push/pop operation for the copy queue is $O(1)$.
 In contrast, a na\"ive array-based queue often has either push or pop cost $O(n)$ and the other cost $O(1)$ since one of the operations requires shifting the elements of the queue.
 Since the executor threads gulp a queue to operate on it locally, this creates a usage pattern where all elements are popped from the copy queue without any interleaved pushes.
 …
 For many workload, the copy queues grow in size to facilitate the average number of messages in flight and there is no further dynamic allocations.
 One downside of this approach that more storage is allocated than needed, \ie each copy queue is only partially full.
 Comparatively, the individual envelope allocations of a list-based queue mean that the actor system always uses the minimum amount of heap space and cleans up eagerly.
+Comparatively, the individual envelope allocations of a list based queue mean that the actor system always uses the minimum amount of heap space and cleans up eagerly.
 Additionally, bursty workloads can cause the copy queues to allocate a large amounts of space to accommodate the peaks of the throughput, even if most of that storage is not needed for the rest of the workload's execution.
 …
 Initially, the memory reclamation na\"ively reclaims one index of the array per \gls{gulp}, if the array size is above a low fixed threshold.
 However, this approach has a problem.
 The high memory watermark nearly doubled!
 The issue is highlighted with an example.
+The high memory usage watermark nearly doubled!
+The issue can easily be highlighted with an example.
 Assume a fixed throughput workload, where a queue never has more than 19 messages at a time.
 If the copy queue starts with a size of 10, it ends up doubling at some point to size 20 to accommodate 19 messages.
 However, after 2 gulps and subsequent reclamations the array size is 18.
 The next time 19 messages are enqueued, the array size is doubled to 36!
+To avoid this issue, a second check is added.
+To avoid this issue a second check is added.
+Each copy queue started tracking the utilization of its array size.
 Reclamation only occurs if less than half of the array is utilized.
+This check achieves a lower total storage and overall memory utilization compared to the non-reclamation copy queues.
+However, the use of copy queues still incurs a higher memory cost than list-based queueing, but the increase in memory usage is reasonable considering the performance gains \see{Section~\ref{s:actor_perf}}.
+In doing this, the reclamation scheme is able to achieve a lower high-watermark and a lower overall memory utilization compared to the non-reclamation copy queues.
+However, the use of copy queues still incurs a higher memory cost than list-based queueing.
+With the inclusion of a memory reclamation scheme the increase in memory usage is reasonable considering the performance gains and is discussed further in Section~\ref{s:actor_perf}.
 \section{Work Stealing}\label{s:steal}
 Work stealing is a scheduling strategy to provide \Newterm{load balance}.
 The goal is to increase resource utilization by having idle threads steal work from working threads.
+While there are multiple parts in work-stealing scheduler, the two important components are victim selection and the stealing mechanism.
+Work stealing is a scheduling strategy that attempts to load balance, and increase resource utilization by having idle threads steal work.
+There are many parts that make up a work stealing actor scheduler, but the two that will be highlighted in this work are the stealing mechanism and victim selection.
+% C_TODO enter citation for langs
 \subsection{Stealing Mechanism}
 In work stealing, the stealing worker is called the \Newterm{thief} and the stolen-from worker is called the \Newterm{victim}.
 The stealing mechanism presented here differs from existing work-stealing actor-systems because of the message-centric (inverted) actor-system.
 Other actor systems, such as Akka~\cite{Akka} and CAF~\cite{CAF}, have work stealing, but use an actor-centric system where stealing is dequeuing from a non-empty ready-queue to an empty ready-queue.
 As an example, in CAF, the sharded actor queue is a set of double-ended queues (dequeues).
 When an actor has messages, it is inserted into a worker's dequeue (ready queue).
+In this discussion of work stealing the worker being stolen from will be referred to as the \textbf{victim} and the worker stealing work will be called the \textbf{thief}.
+The stealing mechanism presented here differs from existing work stealing actor systems due the inverted actor system.
+Other actor systems such as Akka \cite{} and CAF \cite{} have work stealing, but since they use an classic actor system that is actor-centric, stealing work is the act of stealing an actor from a dequeue.
+As an example, in CAF, the sharded actor queue is a set of double ended queues (dequeues).
+Whenever an actor is moved to a ready queue, it is inserted into a worker's dequeue.
 Workers then consume actors from the dequeue and execute their behaviours.
 To steal work, thieves take one or more actors from a victim's dequeue.
+By the pigeon hole principle, there are three dequeue operations (push/victim pop/thief pop) that can occur concurrently and only two ends to a dequeue, so work stealing in a dequeue-based system always results in a potential increase in contention on the dequeues.
+This contention can slows down the victim's throughput.
+Note, which end of the dequeue is used for stealing, consuming, and inserting is not discussed since the largest cost is the mutual exclusion and its duration for safely performing the queue operations.
+Work steal now becomes queue stealing, where an entire actor/message queue is stolen, which trivially preserves message ordering in a queue \see{Section~\ref{s:steal}}.
+This action creates contention on the dequeue, which can slow down the throughput of the victim.
+The notion of which end of the dequeue is used for stealing, consuming, and inserting is not discussed since it isn't relevant.
+By the pigeon hole principle there are three dequeue operations (push/victim pop/thief pop) that can occur concurrently and only two ends to a dequeue, so work stealing being present in a dequeue based system will always result in a potential increase in contention on the dequeues.
 % C_TODO: maybe insert stealing diagram
+In \CFA, the actor work-stealing implementation is unique because of the message-centric system.
+In this system, it is impractical to steal actors because an actor's messages are distributed in temporal order along the message queue.
+To ensure sequential actor execution and FIFO message delivery, actor stealing requires finding and removing all of an actor's messages, and inserting them consecutively in another message queue.
+This operation is $O(N)$ with a non-trivial constant.
+The only way for work stealing to become practical is to shard the message queue, which also reduces contention, and steal queues to eliminate queue searching.
+Given queue stealing, the goal is to have a zero-victim-cost stealing mechanism, which does not mean stealing has no cost.
+It means work stealing does not affect the performance of the victim worker.
+The implication is that thieves cannot contend with a victim, and that a victim should perform no stealing related work unless it becomes a thief.
+In theory, this goal is not achievable, but results show the goal is achieved in practice.
+In \CFA's actor system, workers own a set of sharded queues, which they iterate over and gulp.
+If a worker has iterated over its message queues twice without finding any work, it tries to steal a queue from another worker.
+Stealing a queue is done wait-free with a few atomic instructions that can only create contention with other stealing workers, not the victim.
+To steal a queue, a worker does the following:
+In \CFA, the actor work stealing implementation is unique.
+While other systems are concerned with stealing actors, the \CFA actor system steals queues.
+This is a result of \CFA's use of the inverted actor system.
+The goal of the \CFA actor work stealing mechanism is to have a zero-victim-cost stealing mechanism.
+This does not means that stealing has no cost.
+This goal is to ensure that stealing work does not impact the performance of victim workers.
+This means that thieves can not contend with victims, and that victims should perform no stealing related work unless they become a thief.
+In theory this goal is not achieved, but results will be presented that show the goal is achieved in practice.
+In \CFA's actor system workers own a set of sharded queues which they iterate over and gulp.
+If a worker has iterated over the queues they own twice without finding any work, they try to steal a queue from another worker.
+Stealing a queue is done wait-free with a few atomic instructions that can only create contention with other stealing workers.
+To steal a queue a worker does the following:
 \begin{enumerate}[topsep=5pt,itemsep=3pt,parsep=0pt]
 \item
 The thief chooses a victim, which is trivial because all workers are stored in a shared array.
+The thief chooses a victim.
 \item
 The thief starts at a random index in the array of the victim's queues and searches for a candidate queue.
+A candidate queue is any non-empty queue not being processed by the victim and not being stolen by another thief.
+These rules are not strictly enforced.
+A candidate is identified non-atomically, and as such, queues that do not satisfy these rules may be stolen.
+However, steals not meeting the rules do not affect correctness and do not constitute failed steals as the queue is always swapped.
+\item
+Once a candidate queue is chosen, the thief attempts a wait-free swap of a victim's queue to a random empty thief queue.
+If the swap successes, the steal is completed.
+If the swap fails, the victim may have been gulping that message queue or another thief must have attempted to steal the victim's queue.
+In either case, that message queue is highly likely to be empty.
+\item
+Once a thief fails or succeeds in stealing a queue, it iterates over its messages queues again because new messages may have arrived during stealing.
+Stealing is only repeated after two consecutive iterations over its owned queues without finding work.
+A candidate queue is any queue that is not empty, is not being stolen by another thief, and is not being processed by the victim.
+These are not strictly enforced rules.
+The candidate is identified non-atomically and as such queues that do not satisfy these rules may be stolen.
+However, steals that do not meet these requirements do not affect correctness so they are allowed and do not constitute failed steals as the queues will still be swapped.
+\item
+Once a candidate queue is chosen, the thief attempts a wait-free swap of the victim's queue and a random on of the thief's queues.
+This swap can fail.
+If the swap is successful the thief swaps the two queues.
+If the swap fails, another thief must have attempted to steal one of the two queues being swapped.
+Failing to steal is good in this case since stealing a queue that was just swapped would likely result in stealing an empty queue.
 \end{enumerate}
+Once a thief fails or succeeds in stealing a queue, it goes back to its own set of queues and iterates over them again.
+It will only try to steal again once it has completed two consecutive iterations over its owned queues without finding any work.
 The key to the stealing mechanism is that the queues can still be operated on while they are being swapped.
+This functionality eliminates any contention among thieves and victims.
+This eliminates any contention between thieves and victims.
 The first key to this is that actors and workers maintain two distinct arrays of references to queues.
 Actors will always receive messages via the same queues.
 …
 \subsection{Stealing Guarantees}
+% C_TODO insert graphs for each proof
 Given that the stealing operation can potentially fail, it is important to discuss the guarantees provided by the stealing implementation.
 Given a set of $N$ swaps a set of connected directed graphs can be constructed where each vertex is a queue and each edge is a swap directed from a thief queue to a victim queue.
 …
 Since the @Finished@ allocation status is unused for messages, it is used internally to detect if a message has been sent.
 Deallocating a message without sending it could indicate to a user that they are touching freed memory later, or it could point out extra allocations that could be removed.
-\item Detection of messages sent but not received
-As discussed in Section~\ref{s:executor}, once all actors have terminated shutdown is communicated to executor threads via a status flag. Upon termination the executor threads check their queues to see if any contain messages. If they do, an error is reported. Messages being sent but not received means that their allocation action did not occur and their payload was not delivered. Missing the allocation action can lead to memory leaks and missed payloads can cause unpredictable behaviour. Detecting this can indicate a race or logic error in the user's code.
 \end{itemize}

doc/theses/colby_parsons_MMAth/text/mutex_stmt.tex

-              rc84dd61
+              r0b0a285
 \begin{figure}
         \centering
-    \captionsetup[subfloat]{labelfont=footnotesize,textfont=footnotesize}
         \subfloat[AMD]{
                 \resizebox{0.5\textwidth}{!}{\input{figures/nasus_Aggregate_Lock_2.pgf}}
 …
                 \resizebox{0.5\textwidth}{!}{\input{figures/pyke_Aggregate_Lock_2.pgf}}
+        }
-    \bigskip
         \subfloat[AMD]{
 …
                 \resizebox{0.5\textwidth}{!}{\input{figures/pyke_Aggregate_Lock_4.pgf}}
+        }
-    \bigskip
         \subfloat[AMD]{

driver/cfa.cc

-              rc84dd61
+              r0b0a285
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jun  9 14:36:41 2023
 // Update Count     : 479
+// Last Modified On : Tue May 30 10:47:52 2023
+// Update Count     : 478
 //
 …
         #ifdef __ARM_ARCH
         args[nargs++] = "-mno-outline-atomics";                         // use ARM LL/SC instructions for atomics
-        // args[nargs++] = "-march=armv8.2-a+lse";                              // use atomic instructions
         #endif // __ARM_ARCH

libcfa/prelude/builtins.c

-              rc84dd61
+              r0b0a285
 static inline {
         int ?\?( int x, unsigned int y ) { __CFA_EXP__(); }
+        long int ?\?( int x, unsigned int y ) { __CFA_EXP__(); }
         long int ?\?( long int x, unsigned long int y ) { __CFA_EXP__(); }
         long long int ?\?( long long int x, unsigned long long int y ) { __CFA_EXP__(); }
         // unsigned computation may be faster and larger
         unsigned int ?\?( unsigned int x, unsigned int y ) { __CFA_EXP__(); }
+        unsigned long int ?\?( unsigned int x, unsigned int y ) { __CFA_EXP__(); }
         unsigned long int ?\?( unsigned long int x, unsigned long int y ) { __CFA_EXP__(); }
         unsigned long long int ?\?( unsigned long long int x, unsigned long long int y ) { __CFA_EXP__(); }
 …
 static inline {
         int ?\=?( int & x, unsigned int y ) { x = x \ y; return x; }
+        long int ?\=?( int & x, unsigned int y ) { x = x \ y; return x; }
         long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
         long long int ?\=?( long long int & x, unsigned long long int y ) { x = x \ y; return x; }
         unsigned int ?\=?( unsigned int & x, unsigned int y ) { x = x \ y; return x; }
+        unsigned long int ?\=?( unsigned int & x, unsigned int y ) { x = x \ y; return x; }
         unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
         unsigned long long int ?\=?( unsigned long long int & x, unsigned long long int y ) { x = x \ y; return x; }

libcfa/prelude/sync-builtins.cf

-              rc84dd61
+              r0b0a285
 _Bool __sync_bool_compare_and_swap(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
 #endif
-// for all pointer types
 forall(T &) _Bool __sync_bool_compare_and_swap(T * volatile *, T *, T*, ...);
 …
 unsigned __int128 __sync_val_compare_and_swap(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
 #endif
-// for all pointer types
 forall(T &) T * __sync_val_compare_and_swap(T * volatile *, T *, T*,...);
 …
 void __atomic_exchange(volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128 *, int);
 #endif
-// for all pointer types
 forall(T &) T * __atomic_exchange_n(T * volatile *, T *, int);
 forall(T &) void __atomic_exchange(T * volatile *, T **, T **, int);
 …
 void __atomic_load(const volatile unsigned __int128 *, unsigned __int128 *, int);
 #endif
-// for all pointer types
 forall(T &) T * __atomic_load_n(T * const volatile *, int);
 forall(T &) void __atomic_load(T * const volatile *, T **, int);
 …
 _Bool __atomic_compare_exchange   (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128 *, _Bool, int, int);
 #endif
-// for all pointer types
 forall(T &) _Bool __atomic_compare_exchange_n (T * volatile *, T **, T*, _Bool, int, int);
 forall(T &) _Bool __atomic_compare_exchange   (T * volatile *, T **, T**, _Bool, int, int);
 …
 void __atomic_store(volatile unsigned __int128 *, unsigned __int128 *, int);
 #endif
-// for all pointer types
 forall(T &) void __atomic_store_n(T * volatile *, T *, int);
 forall(T &) void __atomic_store(T * volatile *, T **, int);

libcfa/src/common.hfa

-              rc84dd61
+              r0b0a285
 } // extern "C"
 static inline __attribute__((always_inline)) {
         unsigned char abs( signed char v ) { return (int)abs( (int)v ); }
+        unsigned char abs( signed char v ) { return abs( (int)v ); }
         // use default C routine for int
         unsigned long int abs( long int v ) { return labs( v ); }
 …
         unsigned int min( unsigned int v1, unsigned int v2 ) { return v1 < v2 ? v1 : v2; }
         long int min( long int v1, long int v2 ) { return v1 < v2 ? v1 : v2; }
         unsigned long int min( unsigned long int v1, unsigned long int v2 ) { return v1 < v2 ? v1 : v2; }
+        unsigned long int min( unsigned long int v1, unsigned int v2 ) { return v1 < v2 ? v1 : v2; }
         long long int min( long long int v1, long long int v2 ) { return v1 < v2 ? v1 : v2; }
         unsigned long long int min( unsigned long long int v1, unsigned long long int v2 ) { return v1 < v2 ? v1 : v2; }
+        unsigned long long int min( unsigned long long int v1, unsigned int v2 ) { return v1 < v2 ? v1 : v2; }
         forall( T | { int ?<?( T, T ); } )                                      // generic
         T min( T v1, T v2 ) { return v1 < v2 ? v1 : v2; }

libcfa/src/concurrency/actor.hfa

-              rc84dd61
+              r0b0a285
 #define __DEFAULT_EXECUTOR_BUFSIZE__ 10
 #define __STEAL 1 // workstealing toggle. Disjoint from toggles above
+#define __STEAL 0 // workstealing toggle. Disjoint from toggles above
 // workstealing heuristic selection (only set one to be 1)
 …
 enum allocation { Nodelete, Delete, Destroy, Finished }; // allocation status
 typedef allocation (*__receive_fn)(actor &, message &, actor **, message **);
+typedef allocation (*__receive_fn)(actor &, message &);
 struct request {
     actor * receiver;
     message * msg;
     __receive_fn fn;
+    bool stop;
 };
+struct a_msg {
+    int m;
+};
+static inline void ?{}( request & this ) {}
+static inline void ?{}( request & this ) { this.stop = true; } // default ctor makes a sentinel
 static inline void ?{}( request & this, actor * receiver, message * msg, __receive_fn fn ) {
     this.receiver = receiver;
     this.msg = msg;
     this.fn = fn;
+    this.stop = false;
+}
 static inline void ?{}( request & this, request & copy ) {
 …
     this.msg = copy.msg;
     this.fn = copy.fn;
+    this.stop = copy.stop;
+}
 …
     last_size = 0;
+}
+static inline void ^?{}( copy_queue & this ) with(this) {
+    DEBUG_ABORT( count != 0, "Actor system terminated with messages sent but not received\n" );
+    adelete(buffer);
+}
+static inline void ^?{}( copy_queue & this ) with(this) { adelete(buffer); }
 static inline void insert( copy_queue & this, request & elem ) with(this) {
 …
+}
 static inline bool is_empty( copy_queue & this ) with(this) { return count == 0; }
+static inline bool isEmpty( copy_queue & this ) with(this) { return count == 0; }
 struct work_queue {
 …
     volatile unsigned long long stamp;
     #ifdef ACTOR_STATS
     size_t stolen_from, try_steal, stolen, empty_stolen, failed_swaps, msgs_stolen;
+    size_t stolen_from, try_steal, stolen, failed_swaps, msgs_stolen;
     unsigned long long processed;
     size_t gulps;
 …
     this.gulps = 0;                                 // number of gulps
     this.failed_swaps = 0;                          // steal swap failures
-    this.empty_stolen = 0;                          // queues empty after steal
     this.msgs_stolen = 0;                           // number of messages stolen
     #endif
 …
 #ifdef ACTOR_STATS
 // aggregate counters for statistics
 size_t __total_tries = 0, __total_stolen = 0, __total_workers, __all_gulps = 0, __total_empty_stolen = 0,
+size_t __total_tries = 0, __total_stolen = 0, __total_workers, __all_gulps = 0,
     __total_failed_swaps = 0, __all_processed = 0, __num_actors_stats = 0, __all_msgs_stolen = 0;
 #endif
 …
         unsigned int nprocessors, nworkers, nrqueues;   // number of processors/threads/request queues
         bool seperate_clus;                                                             // use same or separate cluster for executor
-    volatile bool is_shutdown;                      // flag to communicate shutdown to worker threads
 }; // executor
 …
     __atomic_add_fetch(&__total_stolen, executor_->w_infos[id].stolen, __ATOMIC_SEQ_CST);
     __atomic_add_fetch(&__total_failed_swaps, executor_->w_infos[id].failed_swaps, __ATOMIC_SEQ_CST);
-    __atomic_add_fetch(&__total_empty_stolen, executor_->w_infos[id].empty_stolen, __ATOMIC_SEQ_CST);
     // per worker steal stats (uncomment alongside the lock above this routine to print)
 …
     this.nrqueues = nrqueues;
     this.seperate_clus = seperate_clus;
-    this.is_shutdown = false;
     if ( nworkers == nrqueues )
 …
 static inline void ^?{}( executor & this ) with(this) {
+    is_shutdown = true;
+    #ifdef __STEAL
+    request sentinels[nrqueues];
+    for ( unsigned int i = 0; i < nrqueues; i++ ) {
+        insert( request_queues[i], sentinels[i] );              // force eventually termination
+    } // for
+    #else
+    request sentinels[nworkers];
+    unsigned int reqPerWorker = nrqueues / nworkers, extras = nrqueues % nworkers;
+    for ( unsigned int i = 0, step = 0, range; i < nworkers; i += 1, step += range ) {
+        range = reqPerWorker + ( i < extras ? 1 : 0 );
+        insert( request_queues[step], sentinels[i] );           // force eventually termination
+    } // for
+    #endif
     for ( i; nworkers )
 …
     size_t avg_gulps = __all_gulps == 0 ? 0 : __all_processed / __all_gulps;
     printf("\tGulps:\t\t\t\t\t%lu\n\tAverage Gulp Size:\t\t\t%lu\n\tMissed gulps:\t\t\t\t%lu\n", __all_gulps, avg_gulps, misses);
     printf("\tSteal attempts:\t\t\t\t%lu\n\tSteals:\t\t\t\t\t%lu\n\tSteal failures (no candidates):\t\t%lu\n\tSteal failures (failed swaps):\t\t%lu\t Empty steals:\t\t%lu\n",
         __total_tries, __total_stolen, __total_tries - __total_stolen - __total_failed_swaps, __total_failed_swaps, __total_empty_stolen);
+    printf("\tSteal attempts:\t\t\t\t%lu\n\tSteals:\t\t\t\t\t%lu\n\tSteal failures (no candidates):\t\t%lu\n\tSteal failures (failed swaps):\t\t%lu\n",
+        __total_tries, __total_stolen, __total_tries - __total_stolen - __total_failed_swaps, __total_failed_swaps);
     size_t avg_steal = __total_stolen == 0 ? 0 : __all_msgs_stolen / __total_stolen;
     printf("\tMessages stolen:\t\t\t%lu\n\tAverage steal size:\t\t\t%lu\n", __all_msgs_stolen, avg_steal);
 …
 static inline void check_message( message & this ) {
     switch ( this.allocation_ ) {                                               // analyze message status
         case Nodelete: CFA_DEBUG( this.allocation_ = Finished ); break;
+        case Nodelete: CFA_DEBUG(this.allocation_ = Finished); break;
         case Delete: delete( &this ); break;
         case Destroy: ^?{}( this ); break;
+        case Destroy: ^?{}(this); break;
         case Finished: break;
     } // switch
 …
 static inline void deliver_request( request & this ) {
     DEBUG_ABORT( this.receiver->ticket == (unsigned long int)MAX, "Attempted to send message to deleted/dead actor\n" );
+    actor * base_actor;
+    message * base_msg;
+    allocation temp = this.fn( *this.receiver, *this.msg, &base_actor, &base_msg );
+    base_actor->allocation_ = temp;
+    check_message( *base_msg );
+    check_actor( *base_actor );
+    this.receiver->allocation_ = this.fn( *this.receiver, *this.msg );
+    check_message( *this.msg );
+    check_actor( *this.receiver );
+}
 …
         curr_steal_queue = request_queues[ i + vic_start ];
         // avoid empty queues and queues that are being operated on
         if ( curr_steal_queue == 0p || curr_steal_queue->being_processed || is_empty( *curr_steal_queue->c_queue ) )
+        if ( curr_steal_queue == 0p || curr_steal_queue->being_processed || isEmpty( *curr_steal_queue->c_queue ) )
             continue;
 …
             executor_->w_infos[id].msgs_stolen += curr_steal_queue->c_queue->count;
             executor_->w_infos[id].stolen++;
-            if ( is_empty( *curr_steal_queue->c_queue ) ) executor_->w_infos[id].empty_stolen++;
             // __atomic_add_fetch(&executor_->w_infos[victim_id].stolen_from, 1, __ATOMIC_RELAXED);
             // replaced_queue[swap_idx]++;
 …
+}
-#define CHECK_TERMINATION if ( unlikely( executor_->is_shutdown ) ) break Exit
 void main( worker & this ) with(this) {
     // #ifdef ACTOR_STATS
 …
         // check if queue is empty before trying to gulp it
         if ( is_empty( *curr_work_queue->c_queue ) ) {
+        if ( isEmpty( *curr_work_queue->c_queue ) ) {
             #ifdef __STEAL
             empty_count++;
 …
         #endif // ACTOR_STATS
         #ifdef __STEAL
         if ( is_empty( *current_queue ) ) {
             if ( unlikely( no_steal ) ) { CHECK_TERMINATION; continue; }
+        if ( isEmpty( *current_queue ) ) {
+            if ( unlikely( no_steal ) ) continue;
             empty_count++;
             if ( empty_count < steal_threshold ) continue;
             empty_count = 0;
-            CHECK_TERMINATION; // check for termination
             __atomic_store_n( &executor_->w_infos[id].stamp, rdtscl(), __ATOMIC_RELAXED );
 …
+        }
         #endif // __STEAL
         while ( ! is_empty( *current_queue ) ) {
+        while ( ! isEmpty( *current_queue ) ) {
             #ifdef ACTOR_STATS
             executor_->w_infos[id].processed++;
 …
             &req = &remove( *current_queue );
             if ( !&req ) continue;
+            if ( req.stop ) break Exit;
             deliver_request( req );
+        }
 …
         empty_count = 0; // we found work so reset empty counter
         #endif
-        CHECK_TERMINATION;
         // potentially reclaim some of the current queue's vector space if it is unused
 …
     __all_gulps = 0;
     __total_failed_swaps = 0;
-    __total_empty_stolen = 0;
     __all_processed = 0;
     __num_actors_stats = 0;
 …
+}
+static inline void start_actor_system() { start_actor_system( get_proc_count( *active_cluster() ) ); }
+// TODO: potentially revisit getting number of processors
+//  ( currently the value stored in active_cluster()->procs.total is often stale
+//  and doesn't reflect how many procs are allocated )
+// static inline void start_actor_system() { start_actor_system( active_cluster()->procs.total ); }
+static inline void start_actor_system() { start_actor_system( 1 ); }
 static inline void start_actor_system( executor & this ) {
 …
 static inline void stop_actor_system() {
     park( ); // will be unparked when actor system is finished
+    park( ); // will receive signal when actor system is finished
     if ( !__actor_executor_passed ) delete( __actor_executor_ );

libcfa/src/concurrency/atomic.hfa

-              rc84dd61
+              r0b0a285
 // Created On       : Thu May 25 15:22:46 2023
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jun 14 07:48:57 2023
 // Update Count     : 52
+// Last Modified On : Fri Jun  9 13:36:47 2023
+// Update Count     : 46
 //
 …
 // #define CAS( assn, comp, replace ) (CASM( assn, comp, replace, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST))
+// #define CASM( assn, comp, replace, memorder... ) ({ typeof(comp) __temp = (comp); __atomic_compare_exchange_n( &(assn), &(__temp), (replace), false, memorder ); })
+// #define CASM( assn, comp, replace, memorder... ) ({ \
+//      typeof(comp) __temp = (comp); \
+//      __atomic_compare_exchange_n( &(assn), &(__temp), (replace), false, memorder ); \
+// })
 #define CAS( assn, comp, replace ) (__sync_bool_compare_and_swap( &assn, comp, replace))
 #define CASM( assn, comp, replace, memorder... ) _Static_assert( false, "memory order unsupported for CAS macro" );

libcfa/src/concurrency/kernel.hfa

-              rc84dd61
+              r0b0a285
         // Total number of processors
         unsigned total;
-    // Number of processors constructed
-    //  incremented at construction time, total is incremented once the processor asyncronously registers
-        unsigned constructed;
         // Total number of idle processors
 …
 static inline struct cluster   * active_cluster  () { return publicTLS_get( this_processor )->cltr; }
-// gets the number of constructed processors on the cluster
-static inline unsigned get_proc_count( cluster & this ) { return this.procs.constructed; }
 // set the number of internal processors
 // these processors are in addition to any explicitly declared processors

libcfa/src/concurrency/kernel/cluster.hfa

rc84dd61	r0b0a285
40	40
41	41	// convert to log2 scale but using double
42		static inline __readyQ_avg_t __to_readyQ_avg(unsigned long long intsc) { if(unlikely(0 == intsc)) return 0.0; else return log2(~~(__readyQ_avg_t)~~intsc); }
	42	static inline __readyQ_avg_t __to_readyQ_avg(unsigned long long intsc) { if(unlikely(0 == intsc)) return 0.0; else return log2(intsc); }
43	43
44	44	#define warn_large_before warnf( !strict \|\| old_avg < 35.0, "Suspiciously large previous average: %'lf, %'" PRId64 "ms \n", old_avg, program()`ms )

libcfa/src/concurrency/kernel/startup.cfa

-              rc84dd61
+              r0b0a285
         this.name = name;
         this.cltr = &_cltr;
-    __atomic_add_fetch( &_cltr.procs.constructed, 1u, __ATOMIC_RELAXED );
         this.rdq.its = 0;
         this.rdq.itr = 0;
 …
         __cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this);
-    __atomic_sub_fetch( &this.cltr->procs.constructed, 1u, __ATOMIC_RELAXED );
         __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
         __disable_interrupts_checked();
 …
         this.fdw   = 0p;
         this.idle  = 0;
-    this.constructed = 0;
         this.total = 0;
+}

libcfa/src/concurrency/locks.hfa

rc84dd61	r0b0a285
35	35	#include <linux/futex.h> /* Definition of FUTEX_* constants */
36	36	#include <sys/syscall.h> /* Definition of SYS_* constants */
37		#include <unistd.h> ~~/* Definition of syscall routine */~~
	37	#include <unistd.h>
38	38
39	39	typedef void (__cfa_pre_park)( void );

libcfa/src/fstream.cfa

-              rc84dd61
+              r0b0a285
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun 17 08:51:12 2023
 // Update Count     : 528
+// Last Modified On : Mon Jun  5 22:00:23 2023
+// Update Count     : 518
 //
 …
           if ( cnt == 9 ) abort( "ofstream fmt EINTR spinning exceeded" );
     } // for
+        if ( len == EOF ) {                                                                     // error writing ?
+                abort | IO_MSG "invalid write";
+        if ( len == EOF ) {
+                if ( ferror( (FILE *)(os.file$) ) ) {
+                        abort | IO_MSG "invalid write";
+                } // if
         } // if
         va_end( args );
 …
           if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
     } // for
         if ( len == EOF ) {                                                                     // EOF or matching failure ?
                 if ( ! feof( (FILE *)(is.file$) ) && ferror( (FILE *)(is.file$) ) ) {
+        if ( len == EOF ) {
+                if ( ferror( (FILE *)(is.file$) ) ) {
                         abort | IO_MSG "invalid read";
                 } // if

libcfa/src/iostream.hfa

-              rc84dd61
+              r0b0a285
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun 15 22:34:31 2023
 // Update Count     : 411
+// Last Modified On : Thu Feb  2 11:25:39 2023
+// Update Count     : 410
 //
 …
         int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
 }; // basic_ostream
 forall( ostype & | basic_ostream( ostype ) )
 trait ostream {
 …
 forall( T, ostype & | ostream( ostype ) )
 trait writeable {
+        trait writeable {
         ostype & ?|?( ostype &, T );
 }; // writeable
 …
 // *********************************** manipulators ***********************************
-struct _Ostream_Flags {
-        unsigned char eng:1;                                                            // engineering notation
-        unsigned char neg:1;                                                            // val is negative
-        unsigned char pc:1;                                                                     // precision specified
-        unsigned char left:1;                                                           // left justify
-        unsigned char nobsdp:1;                                                         // base prefix / decimal point
-        unsigned char sign:1;                                                           // plus / minus sign
-        unsigned char pad0:1;                                                           // zero pad
-};
 forall( T )
 struct _Ostream_Manip {
 …
         union {
                 unsigned char all;
+                _Ostream_Flags flags;
+                struct {
+                        unsigned char eng:1;                                            // engineering notation
+                        unsigned char neg:1;                                            // val is negative
+                        unsigned char pc:1;                                                     // precision specified
+                        unsigned char left:1;                                           // left justify
+                        unsigned char nobsdp:1;                                         // base prefix / decimal point
+                        unsigned char sign:1;                                           // plus / minus sign
+                        unsigned char pad0:1;                                           // zero pad
+                } flags;
         };
 }; // _Ostream_Manip

libcfa/src/math.hfa

-              rc84dd61
+              r0b0a285
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jun 18 08:13:53 2023
 // Update Count     : 202
+// Last Modified On : Sat Oct  8 08:40:42 2022
+// Update Count     : 136
 //
 …
         return (i << 32) + (sum);
 } // log2_u32_32
+}
 //---------------------- Trigonometric ----------------------
 …
 inline __attribute__((always_inline)) static {
+        // force divide before multiply
+        signed char floor( signed char n, signed char align ) { return (n / align) * align; }
+        unsigned char floor( unsigned char n, unsigned char align ) { return (n / align) * align; }
+        short int floor( short int n, short int align ) { return (n / align) * align; }
+        unsigned short int floor( unsigned short int n, unsigned short int align ) { return (n / align) * align; }
+        int floor( int n, int align ) { return (n / align) * align; }
+        unsigned int floor( unsigned int n, unsigned int align ) { return (n / align) * align; }
+        long int floor( long int n, long int align ) { return (n / align) * align; }
+        unsigned long int floor( unsigned long int n, unsigned long int align ) { return (n / align) * align; }
+        long long int floor( long long int n, long long int align ) { return (n / align) * align; }
+        unsigned long long int floor( unsigned long long int n, unsigned long long int align ) { return (n / align) * align; }
+        signed char floor( signed char n, signed char align ) { return n / align * align; }
+        unsigned char floor( unsigned char n, unsigned char align ) { return n / align * align; }
+        short int floor( short int n, short int align ) { return n / align * align; }
+        unsigned short int floor( unsigned short int n, unsigned short int align ) { return n / align * align; }
+        int floor( int n, int align ) { return n / align * align; }
+        unsigned int floor( unsigned int n, unsigned int align ) { return n / align * align; }
+        long int floor( long int n, long int align ) { return n / align * align; }
+        unsigned long int floor( unsigned long int n, unsigned long int align ) { return n / align * align; }
+        long long int floor( long long int n, long long int align ) { return n / align * align; }
+        unsigned long long int floor( unsigned long long int n, unsigned long long int align ) { return n / align * align; }
         // forall( T | { T ?/?( T, T ); T ?*?( T, T ); } )
+        // T floor( T n, T align ) { return (n / align) * align; }
+        signed char ceiling_div( signed char n, char align ) { return (n + (align - 1hh)) / align; }
+        unsigned char ceiling_div( unsigned char n, unsigned char align ) { return (n + (align - 1hhu)) / align; }
+        short int ceiling_div( short int n, short int align ) { return (n + (align - 1h)) / align; }
+        unsigned short int ceiling_div( unsigned short int n, unsigned short int align ) { return (n + (align - 1hu)) / align; }
+        int ceiling_div( int n, int align ) { return (n + (align - 1n)) / align; }
+        unsigned int ceiling_div( unsigned int n, unsigned int align ) { return (n + (align - 1nu)) / align; }
+        long int ceiling_div( long int n, long int align ) { return (n + (align - 1l)) / align; }
+        unsigned long int ceiling_div( unsigned long int n, unsigned long int align ) { return (n + (align - 1lu)) / align; }
+        long long int ceiling_div( long long int n, long long int align ) { return (n + (align - 1ll)) / align; }
+        unsigned long long int ceiling_div( unsigned long long int n, unsigned long long int align ) { return (n + (align - 1llu)) / align; }
+        signed char ceiling( signed char n, char align ) {
+                typeof(n) trunc = floor( n, align );
+                return n < 0 || n == trunc ? trunc : trunc + align;
+        }
+        unsigned char ceiling( unsigned char n, unsigned char align ) {
+                typeof(n) trunc = floor( n, align );
+                return n == trunc ? trunc : trunc + align;
+        }
+        short int ceiling( short int n, short int align ) {
+                typeof(n) trunc = floor( n, align );
+                return n < 0 || n == trunc ? trunc : trunc + align;
+        }
+        unsigned short int ceiling( unsigned short int n, unsigned short int align ) {
+                typeof(n) trunc = floor( n, align );
+                return n == trunc ? trunc : trunc + align;
+        }
+        int ceiling( int n, int align ) {
+                typeof(n) trunc = floor( n, align );
+                return n < 0 || n == trunc ? trunc : trunc + align;
+        }
+        unsigned int ceiling( unsigned int n, unsigned int align ) {
+                typeof(n) trunc = floor( n, align );
+                return n == trunc ? trunc : trunc + align;
+        }
+        long int ceiling( long int n, long int align ) {
+                typeof(n) trunc = floor( n, align );
+                return n < 0 || n == trunc ? trunc : trunc + align;
+        }
+        unsigned long int ceiling( unsigned long int n, unsigned long int align ) {
+                typeof(n) trunc = floor( n, align );
+                return n == trunc ? trunc : trunc + align;
+        }
+        long long int ceiling( long long int n, signed long long int align ) {
+                typeof(n) trunc = floor( n, align );
+                return n < 0 || n == trunc ? trunc : trunc + align;
+        }
+        unsigned long long int ceiling( unsigned long long int n, unsigned long long int align ) {
+                typeof(n) trunc = floor( n, align );
+                return n == trunc ? trunc : trunc + align;
+        }
+        // T floor( T n, T align ) { return n / align * align; }
+        signed char ceiling_div( signed char n, char align ) { return (n + (align - 1)) / align; }
+        unsigned char ceiling_div( unsigned char n, unsigned char align ) { return (n + (align - 1)) / align; }
+        short int ceiling_div( short int n, short int align ) { return (n + (align - 1)) / align; }
+        unsigned short int ceiling_div( unsigned short int n, unsigned short int align ) { return (n + (align - 1)) / align; }
+        int ceiling_div( int n, int align ) { return (n + (align - 1)) / align; }
+        unsigned int ceiling_div( unsigned int n, unsigned int align ) { return (n + (align - 1)) / align; }
+        long int ceiling_div( long int n, long int align ) { return (n + (align - 1)) / align; }
+        unsigned long int ceiling_div( unsigned long int n, unsigned long int align ) { return (n + (align - 1)) / align; }
+        long long int ceiling_div( long long int n, long long int align ) { return (n + (align - 1)) / align; }
+        unsigned long long int ceiling_div( unsigned long long int n, unsigned long long int align ) { return (n + (align - 1)) / align; }
+        // forall( T | { T ?+?( T, T ); T ?-?( T, T ); T ?%?( T, T ); } )
+        // T ceiling_div( T n, T align ) { verify( is_pow2( align ) );return (n + (align - 1)) / align; }
+        // gcc notices the div/mod pair and saves both so only one div.
+        signed char ceiling( signed char n, signed char align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        unsigned char ceiling( unsigned char n, unsigned char align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        short int ceiling( short int n, short int align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        unsigned short int ceiling( unsigned short int n, unsigned short int align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        int ceiling( int n, int align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        unsigned int ceiling( unsigned int n, unsigned int align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        long int ceiling( long int n, long int align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        unsigned long int ceiling( unsigned long int n, unsigned long int align ) { return floor( n + (n % align != 0 ? align - 1 : 0) , align); }
+        long long int ceiling( long long int n, long long int align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        unsigned long long int ceiling( unsigned long long int n, unsigned long long int align ) { return floor( n + (n % align != 0 ? align - 1 : 0), align ); }
+        // forall( T | { void ?{}( T &, one_t ); T ?+?( T, T ); T ?-?( T, T ); T ?/?( T, T ); } )
+        // T ceiling( T n, T align ) { return return floor( n + (n % align != 0 ? align - 1 : 0), align ); *}
         float floor( float x ) { return floorf( x ); }

libcfa/src/stdlib.hfa

-              rc84dd61
+              r0b0a285
         char random( void ) { return (unsigned long int)random(); }
         char random( char u ) { return (unsigned long int)random( (unsigned long int)u ); } // [0,u)
+        char random( char u ) { return random( (unsigned long int)u ); } // [0,u)
         char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); } // [l,u)
         int random( void ) { return (long int)random(); }
         int random( int u ) { return (long int)random( (long int)u ); } // [0,u]
+        int random( int u ) { return random( (long int)u ); } // [0,u]
         int random( int l, int u ) { return random( (long int)l, (long int)u ); } // [l,u)
         unsigned int random( void ) { return (unsigned long int)random(); }
         unsigned int random( unsigned int u ) { return (unsigned long int)random( (unsigned long int)u ); } // [0,u]
+        unsigned int random( unsigned int u ) { return random( (unsigned long int)u ); } // [0,u]
         unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); } // [l,u)
 } // distribution

libcfa/src/virtual_dtor.hfa

-              rc84dd61
+              r0b0a285
     __virtual_obj_start = &this;
+}
+static inline bool __CFA_dtor_shutdown( virtual_dtor & this ) with(this) {
+    if ( __virtual_dtor_ptr == 1p ) return true; // stop base dtors from being called twice
+static inline void __CFA_dtor_shutdown( virtual_dtor & this ) with(this) {
     if ( __virtual_dtor_ptr ) {
         void (*dtor_ptr)(virtual_dtor &) = __virtual_dtor_ptr;
         __virtual_dtor_ptr = 0p;
+        dtor_ptr(*((virtual_dtor *)__virtual_obj_start)); // call most derived dtor
+        __virtual_dtor_ptr = 1p; // stop base dtors from being called twice
+        return true;
+        dtor_ptr(*((virtual_dtor *)__virtual_obj_start)); // replace actor with base type
+        return;
+    }
-    return false;
+}
 static inline void __CFA_virt_free( virtual_dtor & this ) { free( this.__virtual_obj_start ); }

src/AST/Convert.cpp

-              rc84dd61
+              r0b0a285
                                 old->location,
                                 GET_ACCEPT_1(arg, Expr),
+                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast,
+                                (ast::CastExpr::CastKind) old->kind
+                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
+                        )
                 );

src/AST/Expr.cpp

-              rc84dd61
+              r0b0a285
 // --- CastExpr
 CastExpr::CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g, CastKind kind )
 : Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ), kind( kind ) {}
+CastExpr::CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g )
+: Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ) {}
 bool CastExpr::get_lvalue() const {

src/AST/Expr.hpp

-              rc84dd61
+              r0b0a285
                 const Expr * e )
         : decl( id ), declptr( declptr ), actualType( actual ), formalType( formal ), expr( e ) {}
-        operator bool() {return declptr;}
 };
 …
         GeneratedFlag isGenerated;
-        enum CastKind {
-                Default, // C
-                Coerce, // reinterpret cast
-                Return  // overload selection
-        };
-        CastKind kind = Default;
         CastExpr( const CodeLocation & loc, const Expr * a, const Type * to,
                 GeneratedFlag g = GeneratedCast, CastKind kind = Default ) : Expr( loc, to ), arg( a ), isGenerated( g ), kind( kind ) {}
+                GeneratedFlag g = GeneratedCast ) : Expr( loc, to ), arg( a ), isGenerated( g ) {}
         /// Cast-to-void
         CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast, CastKind kind = Default );
+        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast );
         /// Wrap a cast expression around an existing expression (always generated)

src/AST/SymbolTable.cpp

-              rc84dd61
+              r0b0a285
 #include "Copy.hpp"
-#include <iostream>
-#include <algorithm>
 #include "Decl.hpp"
 #include "Expr.hpp"
 …
                         out.push_back(decl.second);
+                }
-                // std::cerr << otypeKey << ' ' << out.size() << std::endl;
+        }

src/AST/Type.hpp

-              rc84dd61
+              r0b0a285
         bool operator==(const TypeEnvKey & other) const;
         bool operator<(const TypeEnvKey & other) const;
+        operator bool() {return base;}
+};
+};
 /// tuple type e.g. `[int, char]`

src/AST/TypeEnvironment.cpp

rc84dd61	r0b0a285
135	135	}
136	136	}
137		// sub.normalize();
	137	sub.normalize();
138	138	}
139	139

src/AST/TypeEnvironment.hpp

rc84dd61	r0b0a285
63	63
64	64	int cmp = d1->var->name.compare( d2->var->name );
65		return cmp > 0 \|\| ( cmp == 0 && d1->result < d2->result );
	65	return cmp < 0 \|\| ( cmp == 0 && d1->result < d2->result );
66	66	}
67	67	};

src/Concurrency/Actors.cpp

-              rc84dd61
+              r0b0a285
         if ( actorIter != actorStructDecls.end() && messageIter != messageStructDecls.end() ) {
             //////////////////////////////////////////////////////////////////////
-            // The following generates this wrapper for all receive(derived_actor &, derived_msg &) functions
-            /* base_actor and base_msg are output params
-            static inline allocation __CFA_receive_wrap( derived_actor & receiver, derived_msg & msg, actor ** base_actor, message ** base_msg ) {
-                base_actor = &receiver;
-                base_msg = &msg;
-                return receive( receiver, msg );
+            }
-            */
-            CompoundStmt * wrapBody = new CompoundStmt( decl->location );
-            // generates: base_actor = &receiver;
-            wrapBody->push_back( new ExprStmt( decl->location,
-                UntypedExpr::createAssign( decl->location,
-                    UntypedExpr::createDeref( decl->location, new NameExpr( decl->location, "base_actor" ) ),
-                    new AddressExpr( decl->location, new NameExpr( decl->location, "receiver" ) )
+                )
-            ));
-            // generates: base_msg = &msg;
-            wrapBody->push_back( new ExprStmt( decl->location,
-                UntypedExpr::createAssign( decl->location,
-                    UntypedExpr::createDeref( decl->location, new NameExpr( decl->location, "base_msg" ) ),
-                    new AddressExpr( decl->location, new NameExpr( decl->location, "msg" ) )
+                )
-            ));
-            // generates: return receive( receiver, msg );
-            wrapBody->push_back( new ReturnStmt( decl->location,
-                new UntypedExpr ( decl->location,
-                    new NameExpr( decl->location, "receive" ),
+                    {
-                        new NameExpr( decl->location, "receiver" ),
-                        new NameExpr( decl->location, "msg" )
+                    }
+                )
-            ));
-            // create receive wrapper to extract base message and actor pointer
-            // put it all together into the complete function decl from above
-            FunctionDecl * receiveWrapper = new FunctionDecl(
-                decl->location,
-                "__CFA_receive_wrap",
-                {},                     // forall
+                {
-                    new ObjectDecl(
-                        decl->location,
-                        "receiver",
-                        ast::deepCopy( derivedActorRef )
-                    ),
-                    new ObjectDecl(
-                        decl->location,
-                        "msg",
-                        ast::deepCopy( derivedMsgRef )
-                    ),
-                    new ObjectDecl(
-                        decl->location,
-                        "base_actor",
-                        new PointerType( new PointerType( new StructInstType( *actorDecl ) ) )
-                    ),
-                    new ObjectDecl(
-                        decl->location,
-                        "base_msg",
-                        new PointerType( new PointerType( new StructInstType( *msgDecl ) ) )
+                    )
-                },                      // params
+                {
-                    new ObjectDecl(
-                        decl->location,
-                        "__CFA_receive_wrap_ret",
-                        new EnumInstType( *allocationDecl )
+                    )
-                },
-                wrapBody,               // body
-                { Storage::Static },    // storage
-                Linkage::Cforall,       // linkage
-                {},                     // attributes
-                { Function::Inline }
-            );
-            declsToAddAfter.push_back( receiveWrapper );
-            //////////////////////////////////////////////////////////////////////
             // The following generates this send message operator routine for all receive(derived_actor &, derived_msg &) functions
             /*
 …
             ));
             // Function type is: allocation (*)( derived_actor &, derived_msg &, actor **, message ** )
+            // Function type is: allocation (*)( derived_actor &, derived_msg & )
             FunctionType * derivedReceive = new FunctionType();
             derivedReceive->params.push_back( ast::deepCopy( derivedActorRef ) );
             derivedReceive->params.push_back( ast::deepCopy( derivedMsgRef ) );
-            derivedReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *actorDecl ) ) ) );
-            derivedReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *msgDecl ) ) ) );
             derivedReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
             // Generates: allocation (*my_work_fn)( derived_actor &, derived_msg &, actor **, message ** ) = receive;
+            // Generates: allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
             sendBody->push_back( new DeclStmt(
                 decl->location,
 …
                     "my_work_fn",
                     new PointerType( derivedReceive ),
                     new SingleInit( decl->location, new NameExpr( decl->location, "__CFA_receive_wrap" ) )
+                    new SingleInit( decl->location, new NameExpr( decl->location, "receive" ) )
+                )
             ));
 …
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *actorDecl ) ) );
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *msgDecl ) ) );
-            genericReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *actorDecl ) ) ) );
-            genericReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *msgDecl ) ) ) );
             genericReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
 …
             ));
             // Generates: new_req{ (actor *)&receiver, (message *)&msg, fn };
+            // Generates: new_req{ &receiver, &msg, fn };
             sendBody->push_back( new ExprStmt(
                 decl->location,
 …
+                                        {
                                                 new NameExpr( decl->location, "new_req" ),
                         new CastExpr( decl->location, new AddressExpr( new NameExpr( decl->location, "receiver" ) ), new PointerType( new StructInstType( *actorDecl ) ), ExplicitCast ),
                         new CastExpr( decl->location, new AddressExpr( new NameExpr( decl->location, "msg" ) ), new PointerType( new StructInstType( *msgDecl ) ), ExplicitCast ),
+                        new AddressExpr( new NameExpr( decl->location, "receiver" ) ),
+                        new AddressExpr( new NameExpr( decl->location, "msg" ) ),
                         new NameExpr( decl->location, "fn" )
+                                        }
 …
             FunctionDecl * sendOperatorFunction = new FunctionDecl(
                 decl->location,
                 "?|?",
+                "?<<?",
                 {},                     // forall
+                {

src/GenPoly/SpecializeNew.cpp

-              rc84dd61
+              r0b0a285
         using namespace ResolvExpr;
         ast::OpenVarSet openVars, closedVars;
+        ast::AssertionSet need, have; // unused
+        ast::TypeEnvironment env; // unused
+        // findOpenVars( formalType, openVars, closedVars, need, have, FirstClosed );
+        findOpenVars( actualType, openVars, closedVars, need, have, env, FirstOpen );
+        ast::AssertionSet need, have;
+        findOpenVars( formalType, openVars, closedVars, need, have, FirstClosed );
+        findOpenVars( actualType, openVars, closedVars, need, have, FirstOpen );
         for ( const ast::OpenVarSet::value_type & openVar : openVars ) {
                 const ast::Type * boundType = subs->lookup( openVar.first );
 …
                         if ( closedVars.find( *inst ) == closedVars.end() ) {
                                 return true;
+                        }
-                        else {
-                                assertf(false, "closed: %s", inst->name.c_str());
+                        }
                 // Otherwise, the variable is bound to a concrete type.

src/Parser/DeclarationNode.cc

-              rc84dd61
+              r0b0a285
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun 17 14:41:48 2023
 // Update Count     : 1405
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Apr 20 11:46:00 2023
+// Update Count     : 1393
 //
 …
         std::vector<ast::ptr<ast::Expr>> exprs;
         buildList( expr, exprs );
+        newnode->attributes.push_back( new ast::Attribute( *name, std::move( exprs ) ) );
+        newnode->attributes.push_back(
+                new ast::Attribute( *name, std::move( exprs ) ) );
         delete name;
         return newnode;
 …
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
+                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::basicTypeNames[ dst->basictype ] +
+                                                                   "\" and \"" + DeclarationNode::basicTypeNames[ src->basictype ] + "\"." );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " );
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
+                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::complexTypeNames[ src->complextype ] +
+                                                                   "\" and \"" + DeclarationNode::complexTypeNames[ src->complextype ] + "\"." );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " );
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
+                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::signednessNames[ dst->signedness ] +
+                                                                   "\" and \"" + DeclarationNode::signednessNames[ src->signedness ] + "\"." );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
                                 if ( dst->length == DeclarationNode::NoLength ) {
 …
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
+                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::lengthNames[ dst->length ] +
+                                                                   "\" and \"" + DeclarationNode::lengthNames[ src->length ] + "\"." );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
                         } // if
                         break;
 …
 DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) {
         if ( o && o->type)  {
+        if ( o && o -> type)  {
                 type->base= o->type;
         } // if
+        }
         delete o;
         return this;
 …
+}
 // If a typedef wraps an anonymous declaration, name the inner declaration so it has a consistent name across
 // translation units.
+// If a typedef wraps an anonymous declaration, name the inner declaration
+// so it has a consistent name across translation units.
 static void nameTypedefedDecl(
                 DeclarationNode * innerDecl,
 …
+}
+void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::Decl>> & outputList ) {
+void buildList( DeclarationNode * firstNode,
+                std::vector<ast::ptr<ast::Decl>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );

src/Parser/ExpressionNode.cc

-              rc84dd61
+              r0b0a285
 ast::Expr * build_cast( const CodeLocation & location,
                 DeclarationNode * decl_node,
+                ExpressionNode * expr_node,
+                ast::CastExpr::CastKind kind ) {
+                ExpressionNode * expr_node ) {
         ast::Type * targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast<ast::VoidType *>( targetType ) ) {
 …
                 return new ast::CastExpr( location,
                         maybeMoveBuild( expr_node ),
                         ast::ExplicitCast, kind );
+                        ast::ExplicitCast );
         } else {
                 return new ast::CastExpr( location,
                         maybeMoveBuild( expr_node ),
                         targetType,
                         ast::ExplicitCast, kind );
+                        ast::ExplicitCast );
         } // if
 } // build_cast

src/Parser/ExpressionNode.h

rc84dd61	r0b0a285
69	69	ast::DimensionExpr * build_dimensionref( const CodeLocation &, const std::string * name );
70	70
71		ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node~~, ast::CastExpr::CastKind kind = ast::CastExpr::Default~~ );
	71	ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );
72	72	ast::Expr * build_keyword_cast( const CodeLocation &, ast::AggregateDecl::Aggregate target, ExpressionNode * expr_node );
73	73	ast::Expr * build_virtual_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );

src/Parser/parser.yy

-              rc84dd61
+              r0b0a285
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun 17 18:53:24 2023
 // Update Count     : 6347
+// Last Modified On : Wed Jun  7 14:32:28 2023
+// Update Count     : 6341
 //
 …
                 { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
                 { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::CastExpr::Return ) ); }
+                { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
 …
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
                 { $$ = new ExpressionNode( build_cond( yylloc, $1, $1->clone(), $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+        ;

src/ResolvExpr/Candidate.hpp

-              rc84dd61
+              r0b0a285
 /// Holdover behaviour from old `findMinCost` -- xxx -- can maybe be eliminated?
-/*
 static inline void promoteCvtCost( CandidateList & candidates ) {
         for ( CandidateRef & r : candidates ) {
 …
+        }
+}
-*/
 void print( std::ostream & os, const Candidate & cand, Indenter indent = {} );

src/ResolvExpr/CandidateFinder.cpp

-              rc84dd61
+              r0b0a285
 #include "typeops.h"              // for combos
 #include "Unify.h"
-#include "WidenMode.h"
 #include "AST/Expr.hpp"
 #include "AST/Node.hpp"
 …
                         // attempt to narrow based on expected target type
                         const ast::Type * returnType = funcType->returns.front();
+                        if ( selfFinder.strictMode ) {
+                                if ( ! unifyExact(
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, noWiden() ) // xxx - is no widening correct?
+                                ) {
+                                        // unification failed, do not pursue this candidate
+                                        return;
+                                }
+                        }
+                        else {
+                                if ( ! unify(
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen )
+                                ) {
+                                        // unification failed, do not pursue this candidate
+                                        return;
+                                }
+                        if ( ! unify(
+                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen )
+                        ) {
+                                // unification failed, do not pursue this candidate
+                                return;
+                        }
+                }
 …
                                 for (size_t i=0; i<nParams; ++i) {
                                         auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
                                         if ( !instantiateArgument( location,
+                                        if (!instantiateArgument( location,
                                                 funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                }
 …
                         // matches
                         // no default args for indirect calls
                         if ( !instantiateArgument( location,
+                        if ( ! instantiateArgument( location,
                                 param, nullptr, args, results, genStart, symtab ) ) return;
+                }
 …
                 if ( auto structInst = aggrExpr->result.as< ast::StructInstType >() ) {
                         addAggMembers( structInst, aggrExpr, *cand, Cost::unsafe, "" );
+                        addAggMembers( structInst, aggrExpr, *cand, Cost::safe, "" );
                 } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
                         addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
+                        addAggMembers( unionInst, aggrExpr, *cand, Cost::safe, "" );
+                }
+        }
 …
                                 if ( auto pointer = dynamic_cast< const ast::PointerType * >( funcResult ) ) {
                                         if ( auto function = pointer->base.as< ast::FunctionType >() ) {
-                                                // if (!selfFinder.allowVoid && function->returns.empty()) continue;
                                                 CandidateRef newFunc{ new Candidate{ *func } };
                                                 newFunc->expr =
 …
                                         if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
                                                 if ( auto function = clz->bound.as< ast::FunctionType >() ) {
                                                         CandidateRef newFunc( new Candidate( *func ) );
+                                                        CandidateRef newFunc{ new Candidate{ *func } };
                                                         newFunc->expr =
                                                                 referenceToRvalueConversion( newFunc->expr, newFunc->cost );
 …
                 if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
-                // only keep the best matching intrinsic result to match C semantics (no unexpected narrowing/widening)
-                // TODO: keep one for each set of argument candidates?
-                Cost intrinsicCost = Cost::infinity;
-                CandidateList intrinsicResult;
                 // Compute conversion costs
                 for ( CandidateRef & withFunc : found ) {
 …
                         if ( cvtCost != Cost::infinity ) {
                                 withFunc->cvtCost = cvtCost;
+                                withFunc->cost += cvtCost;
+                                auto func = withFunc->expr.strict_as<ast::ApplicationExpr>()->func.as<ast::VariableExpr>();
+                                if (func && func->var->linkage == ast::Linkage::Intrinsic) {
+                                        if (withFunc->cost < intrinsicCost) {
+                                                intrinsicResult.clear();
+                                                intrinsicCost = withFunc->cost;
+                                        }
+                                        if (withFunc->cost == intrinsicCost) {
+                                                intrinsicResult.emplace_back(std::move(withFunc));
+                                        }
+                                }
+                                else {
+                                        candidates.emplace_back( std::move( withFunc ) );
+                                }
+                        }
+                }
+                spliceBegin( candidates, intrinsicResult );
+                                candidates.emplace_back( std::move( withFunc ) );
+                        }
+                }
                 found = std::move( candidates );
                 // use a new list so that candidates are not examined by addAnonConversions twice
                 // CandidateList winners = findMinCost( found );
                 // promoteCvtCost( winners );
+                CandidateList winners = findMinCost( found );
+                promoteCvtCost( winners );
                 // function may return a struct/union value, in which case we need to add candidates
                 // for implicit conversions to each of the anonymous members, which must happen after
                 // `findMinCost`, since anon conversions are never the cheapest
                 for ( const CandidateRef & c : found ) {
+                for ( const CandidateRef & c : winners ) {
                         addAnonConversions( c );
+                }
+                // would this be too slow when we don't check cost anymore?
+                spliceBegin( candidates, found );
+                if ( candidates.empty() && targetType && ! targetType->isVoid() && !selfFinder.strictMode ) {
+                spliceBegin( candidates, winners );
+                if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
                         // If resolution is unsuccessful with a target type, try again without, since it
                         // will sometimes succeed when it wouldn't with a target type binding.
 …
                 CandidateFinder finder( context, tenv, toType );
-                if (toType->isVoid()) {
-                        finder.allowVoid = true;
+                }
-                if ( castExpr->kind == ast::CastExpr::Return ) {
-                        finder.strictMode = true;
-                        finder.find( castExpr->arg, ResolvMode::withAdjustment() );
-                        // return casts are eliminated (merely selecting an overload, no actual operation)
-                        candidates = std::move(finder.candidates);
+                }
                 finder.find( castExpr->arg, ResolvMode::withAdjustment() );
 …
                 CandidateList matches;
-                Cost minExprCost = Cost::infinity;
-                Cost minCastCost = Cost::infinity;
                 for ( CandidateRef & cand : finder.candidates ) {
                         ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
 …
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
+                                // select first on argument cost, then conversion cost
+                                if ( cand->cost < minExprCost || ( cand->cost == minExprCost && thisCost < minCastCost ) ) {
+                                        minExprCost = cand->cost;
+                                        minCastCost = thisCost;
+                                        matches.clear();
+                                }
+                                // ambiguous case, still output candidates to print in error message
+                                if ( cand->cost == minExprCost && thisCost == minCastCost ) {
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                restructureCast( cand->expr, toType, castExpr->isGenerated ),
+                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost + thisCost);
+                                        // currently assertions are always resolved immediately so this should have no effect.
+                                        // if this somehow changes in the future (e.g. delayed by indeterminate return type)
+                                        // we may need to revisit the logic.
+                                        inferParameters( newCand, matches );
+                                }
+                                // else skip, better alternatives found
+                        }
+                }
+                candidates = std::move(matches);
+                //CandidateList minArgCost = findMinCost( matches );
+                //promoteCvtCost( minArgCost );
+                //candidates = findMinCost( minArgCost );
+                                CandidateRef newCand = std::make_shared<Candidate>(
+                                        restructureCast( cand->expr, toType, castExpr->isGenerated ),
+                                        copy( cand->env ), std::move( open ), std::move( need ), cand->cost,
+                                        cand->cost + thisCost );
+                                inferParameters( newCand, matches );
+                        }
+                }
+                // select first on argument cost, then conversion cost
+                CandidateList minArgCost = findMinCost( matches );
+                promoteCvtCost( minArgCost );
+                candidates = findMinCost( minArgCost );
+        }
 …
                 // candidates for true result
                 CandidateFinder finder2( context, tenv );
-                finder2.allowVoid = true;
                 finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
 …
                 // candidates for false result
                 CandidateFinder finder3( context, tenv );
-                finder3.allowVoid = true;
                 finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
                 if ( finder3.candidates.empty() ) return;
 …
         void Finder::postvisit( const ast::ConstructorExpr * ctorExpr ) {
                 CandidateFinder finder( context, tenv );
-                finder.allowVoid = true;
                 finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() );
                 for ( CandidateRef & r : finder.candidates ) {
 …
                         CandidateFinder finder( context, tenv, toType );
                         finder.find( initExpr->expr, ResolvMode::withAdjustment() );
-                        Cost minExprCost = Cost::infinity;
-                        Cost minCastCost = Cost::infinity;
                         for ( CandidateRef & cand : finder.candidates ) {
                                 if (reason.code == NotFound) reason.code = NoMatch;
 …
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
+                                        if ( cand->cost < minExprCost || ( cand->cost == minExprCost && thisCost < minCastCost ) ) {
+                                                minExprCost = cand->cost;
+                                                minCastCost = thisCost;
+                                                matches.clear();
+                                        }
+                                        // ambiguous case, still output candidates to print in error message
+                                        if ( cand->cost == minExprCost && thisCost == minCastCost ) {
+                                                CandidateRef newCand = std::make_shared<Candidate>(
+                                                        new ast::InitExpr{
+                                                                initExpr->location,
+                                                                restructureCast( cand->expr, toType ),
+                                                                initAlt.designation },
+                                                        std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
+                                                // currently assertions are always resolved immediately so this should have no effect.
+                                                // if this somehow changes in the future (e.g. delayed by indeterminate return type)
+                                                // we may need to revisit the logic.
+                                                inferParameters( newCand, matches );
+                                        }
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                new ast::InitExpr{
+                                                        initExpr->location, restructureCast( cand->expr, toType ),
+                                                        initAlt.designation },
+                                                std::move(env), std::move( open ), std::move( need ), cand->cost, thisCost );
+                                        inferParameters( newCand, matches );
+                                }
+                        }
 …
                 // select first on argument cost, then conversion cost
+                // CandidateList minArgCost = findMinCost( matches );
+                // promoteCvtCost( minArgCost );
+                // candidates = findMinCost( minArgCost );
+                candidates = std::move(matches);
+                CandidateList minArgCost = findMinCost( matches );
+                promoteCvtCost( minArgCost );
+                candidates = findMinCost( minArgCost );
+        }
 …
                         auto found = selected.find( mangleName );
                         if ( found != selected.end() ) {
+                                // tiebreaking by picking the lower cost on CURRENT expression
+                                // NOTE: this behavior is different from C semantics.
+                                // Specific remediations are performed for C operators at postvisit(UntypedExpr).
+                                // Further investigations may take place.
+                                if ( newCand->cost < found->second.candidate->cost
+                                        || (newCand->cost == found->second.candidate->cost && newCand->cvtCost < found->second.candidate->cvtCost) ) {
+                                if ( newCand->cost < found->second.candidate->cost ) {
                                         PRINT(
                                                 std::cerr << "cost " << newCand->cost << " beats "
 …
                                         found->second = PruneStruct{ newCand };
                                 } else if ( newCand->cost == found->second.candidate->cost && newCand->cvtCost == found->second.candidate->cvtCost ) {
+                                } else if ( newCand->cost == found->second.candidate->cost ) {
                                         // if one of the candidates contains a deleted identifier, can pick the other,
                                         // since deleted expressions should not be ambiguous if there is another option
 …
         */
+        // optimization: don't prune for NameExpr since it never has cost
+        if ( mode.prune && !dynamic_cast<const ast::NameExpr *>(expr) ) {
+        if ( mode.prune ) {
                 // trim candidates to single best one
                 PRINT(

src/ResolvExpr/CandidateFinder.hpp

rc84dd61	r0b0a285
33	33	const ast::TypeEnvironment & env; ///< Substitutions performed in this resolution
34	34	ast::ptr< ast::Type > targetType; ///< Target type for resolution
35		~~bool strictMode = false; ///< If set to true, requires targetType to be exact match (inside return cast)~~
36		~~bool allowVoid = false; ///< If set to true, allow void-returning function calls (only top level, cast to void and first in comma)~~
37	35	std::set< std::string > otypeKeys; /// different type may map to same key
38	36

src/ResolvExpr/CastCost.cc

-              rc84dd61
+              r0b0a285
         if ( typesCompatibleIgnoreQualifiers( src, dst, env ) ) {
                 PRINT( std::cerr << "compatible!" << std::endl; )
-                if (dynamic_cast<const ast::ZeroType *>(dst) || dynamic_cast<const ast::OneType *>(dst)) {
-                        return Cost::spec;
+                }
                 return Cost::zero;
         } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {

src/ResolvExpr/CommonType.cc

-              rc84dd61
+              r0b0a285
                         if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
                                 #warning remove casts when `commonTypes` moved to new AST
-                                /*
                                 ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
                                 if (
 …
                                         result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
+                                }
-                                */
-                                ast::BasicType::Kind kind;
-                                if (basic->kind != basic2->kind && !widen.first && !widen.second) return;
-                                else if (!widen.first) kind = basic->kind; // widen.second
-                                else if (!widen.second) kind = basic2->kind;
-                                else kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
-                                // xxx - what does qualifiers even do here??
-                                if ( (basic->qualifiers >= basic2->qualifiers || widen.first)
-                                        && (basic->qualifiers <= basic2->qualifiers || widen.second) ) {
-                                        result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
+                                }
                         } else if (
                                 dynamic_cast< const ast::ZeroType * >( type2 )
 …
                                 #warning remove casts when `commonTypes` moved to new AST
                                 ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
+                                /*
+                                if ( // xxx - what does qualifier even do here??
+                                        ( ( basic->qualifiers >= type2->qualifiers )
+                                if (
+                                        ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
                                                 || widen.first )
                                          && ( ( /* kind != basic->kind && basic->qualifiers <= type2->qualifiers )
+                                        && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
                                                 || widen.second )
+                                )
+                                */
+                                if (widen.second) {
+                                        result = new ast::BasicType{ basic->kind, basic->qualifiers | type2->qualifiers };
+                                ) {
+                                        result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
+                                }
                         } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
 …
                                 auto entry = open.find( *var );
                                 if ( entry != open.end() ) {
-                                // if (tenv.lookup(*var)) {
                                         ast::AssertionSet need, have;
                                         if ( ! tenv.bindVar(

src/ResolvExpr/ConversionCost.cc

-              rc84dd61
+              r0b0a285
         cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
-        // xxx - should qualifiers be considered in pass-by-value?
-        /*
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
 …
                 cost.incUnsafe();
+        }
-        */
-        cost.incReference();
+}
 …
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
+                }
-                // this has the effect of letting any expr such as x+0, x+1 to be typed
-                // the same as x, instead of at least int. are we willing to sacrifice this little
-                // bit of coherence with C?
-                // TODO: currently this does not work when no zero/one overloads exist. Find a fix for it.
-                // cost = Cost::zero;
         } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
                 cost = Cost::zero;
                 // +1 for zero_t ->, +1 for disambiguation
                 cost.incSafe( maxIntCost + 2 );
-                // assuming 0p is supposed to be used for pointers?
+        }
+}
 …
                 cost = Cost::zero;
         } else if ( const ast::BasicType * dstAsBasic =
                         dynamic_cast< const ast::BasicType * >( dst ) ) {
+                        dynamic_cast< const ast::BasicType * >( dst ) ) {
                 int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
                 if ( -1 == tableResult ) {
 …
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
+                }
-                // cost = Cost::zero;
+        }
+}

src/ResolvExpr/FindOpenVars.cc

-              rc84dd61
+              r0b0a285
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
-#include "AST/TypeEnvironment.hpp"
 #include "Common/PassVisitor.h"
 #include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
 #include "SynTree/Type.h"         // for Type, Type::ForallList, ArrayType
-#include <iostream>
 namespace ResolvExpr {
 …
                         ast::AssertionSet & need;
                         ast::AssertionSet & have;
-                        ast::TypeEnvironment & env;
                         bool nextIsOpen;
                         FindOpenVars_new(
                                 ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n,
                                 ast::AssertionSet & h, ast::TypeEnvironment & env, FirstMode firstIsOpen )
                         : open( o ), closed( c ), need( n ), have( h ), env (env), nextIsOpen( firstIsOpen ) {}
+                                ast::AssertionSet & h, FirstMode firstIsOpen )
+                        : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
                         void previsit( const ast::FunctionType * type ) {
                                 // mark open/closed variables
                                 if ( nextIsOpen ) {
-                                        // trying to remove this from resolver.
-                                        // occasionally used in other parts so not deleting right now.
-                                        // insert open variables unbound to environment.
-                                        env.add(type->forall);
                                         for ( auto & decl : type->forall ) {
                                                 open[ *decl ] = ast::TypeData{ decl->base };
 …
         void findOpenVars(
                         const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
                         ast::AssertionSet & need, ast::AssertionSet & have, ast::TypeEnvironment & env, FirstMode firstIsOpen ) {
                 ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, env, firstIsOpen };
+                        ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
+                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
                 type->accept( finder );
-                if (!closed.empty()) {
-                        std::cerr << "closed: ";
-                        for (auto& i : closed) {
-                                std::cerr << i.first.base->location << ":" << i.first.base->name << ' ';
+                        }
-                        std::cerr << std::endl;
+                }
+        }
 } // namespace ResolvExpr

src/ResolvExpr/FindOpenVars.h

rc84dd61	r0b0a285
33	33	void findOpenVars(
34	34	const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
35		ast::AssertionSet & need, ast::AssertionSet & have, ~~ast::TypeEnvironment & env,~~ FirstMode firstIsOpen );
	35	ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen );
36	36	} // namespace ResolvExpr
37	37

src/ResolvExpr/Resolver.cc

-              rc84dd61
+              r0b0a285
                         ast::TypeEnvironment env;
                         CandidateFinder finder( context, env );
-                        finder.allowVoid = true;
                         finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
                         --recursion_level;
 …
                         // promote candidate.cvtCost to .cost
                         // promoteCvtCost( winners );
+                        promoteCvtCost( winners );
                         // produce ambiguous errors, if applicable

src/ResolvExpr/SatisfyAssertions.cpp

-              rc84dd61
+              r0b0a285
 #include "SatisfyAssertions.hpp"
-#include <iostream>
 #include <algorithm>
 #include <cassert>
 …
 #include "SymTab/Mangler.h"
 namespace ResolvExpr {
 …
                         ast::AssertionSet && h, ast::AssertionSet && n, ast::OpenVarSet && o, ast::UniqueId rs )
                 : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
+                  need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {
+                        if (!have.empty()) {
+                                // std::cerr << c.id->location << ':' << c.id->name << std::endl; // I think this was debugging code so I commented it
+                        }
+                  }
+                  need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {}
         };
 …
         };
+        enum AssertionResult {Fail, Skip, Success} ;
+        /// Adds a captured assertion to the symbol table
+        void addToSymbolTable( const ast::AssertionSet & have, ast::SymbolTable & symtab ) {
+                for ( auto & i : have ) {
+                        if ( i.second.isUsed ) { symtab.addId( i.first->var ); }
+                }
+        }
         /// Binds a single assertion, updating satisfaction state
 …
                         "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
                 ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cost );
+                ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cvtCost );
                 varExpr->result = match.adjType;
                 if ( match.resnSlot ) { varExpr->inferred.resnSlots().emplace_back( match.resnSlot ); }
 …
         /// Satisfy a single assertion
         AssertionResult satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool skipUnbound = false) {
+        bool satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool allowConversion = false, bool skipUnbound = false) {
                 // skip unused assertions
+                // static unsigned int cnt = 0; // I think this was debugging code so I commented it
+                if ( ! assn.second.isUsed ) return AssertionResult::Success;
+                // if (assn.first->var->name[1] == '|') std::cerr << ++cnt << std::endl; // I think this was debugging code so I commented it
+                if ( ! assn.second.isUsed ) return true;
                 // find candidates that unify with the desired type
                 AssnCandidateList matches, inexactMatches;
+                AssnCandidateList matches;
                 std::vector<ast::SymbolTable::IdData> candidates;
 …
                                 .strict_as<ast::FunctionType>()->params[0]
                                 .strict_as<ast::ReferenceType>()->base;
+                        // sat.cand->env.apply(thisArgType);
+                        if (auto inst = thisArgType.as<ast::TypeInstType>()) {
+                                auto cls = sat.cand->env.lookup(*inst);
+                                if (cls && cls->bound) thisArgType = cls->bound;
+                        }
+                        sat.cand->env.apply(thisArgType);
                         std::string otypeKey = "";
                         if (thisArgType.as<ast::PointerType>()) otypeKey = Mangle::Encoding::pointer;
                         else if (!isUnboundType(thisArgType)) otypeKey = Mangle::mangle(thisArgType, Mangle::Type | Mangle::NoGenericParams);
                         else if (skipUnbound) return AssertionResult::Skip;
+                        else if (skipUnbound) return false;
                         candidates = sat.symtab.specialLookupId(kind, otypeKey);
 …
                         ast::OpenVarSet closed;
+                        // findOpenVars( toType, newOpen, closed, newNeed, have, FirstClosed );
+                        findOpenVars( adjType, newOpen, closed, newNeed, have, newEnv, FirstOpen );
+                        ast::TypeEnvironment tempNewEnv {newEnv};
+                        if ( unifyExact( toType, adjType, tempNewEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
+                                // set up binding slot for recursive assertions
+                                ast::UniqueId crntResnSlot = 0;
+                                if ( ! newNeed.empty() ) {
+                                        crntResnSlot = ++globalResnSlot;
+                                        for ( auto & a : newNeed ) { a.second.resnSlot = crntResnSlot; }
+                                }
+                                matches.emplace_back(
+                                        cdata, adjType, std::move( tempNewEnv ), std::move( have ), std::move( newNeed ),
+                                        std::move( newOpen ), crntResnSlot );
+                        }
+                        else if ( matches.empty() ) {
+                                // restore invalidated env
+                                // newEnv = sat.cand->env;
+                                // newNeed.clear();
+                        findOpenVars( toType, newOpen, closed, newNeed, have, FirstClosed );
+                        findOpenVars( adjType, newOpen, closed, newNeed, have, FirstOpen );
+                        if ( allowConversion ) {
                                 if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
                                         // set up binding slot for recursive assertions
 …
+                                        }
                                         inexactMatches.emplace_back(
+                                        matches.emplace_back(
                                                 cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
                                                 std::move( newOpen ), crntResnSlot );
+                                }
+                        }
+                        else {
+                                if ( unifyExact( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
+                                        // set up binding slot for recursive assertions
+                                        ast::UniqueId crntResnSlot = 0;
+                                        if ( ! newNeed.empty() ) {
+                                                crntResnSlot = ++globalResnSlot;
+                                                for ( auto & a : newNeed ) { a.second.resnSlot = crntResnSlot; }
+                                        }
+                                        matches.emplace_back(
+                                                cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
+                                                std::move( newOpen ), crntResnSlot );
+                                }
+                        }
+                }
                 // break if no satisfying match
+                if ( matches.empty() ) matches = std::move(inexactMatches);
+                if ( matches.empty() ) return AssertionResult::Fail;
+                if ( matches.empty() ) return false;
                 // defer if too many satisfying matches
                 if ( matches.size() > 1 ) {
                         sat.deferred.emplace_back( assn.first, assn.second, std::move( matches ) );
                         return AssertionResult::Success;
+                        return true;
+                }
                 // otherwise bind unique match in ongoing scope
                 AssnCandidate & match = matches.front();
                 // addToSymbolTable( match.have, sat.symtab );
+                addToSymbolTable( match.have, sat.symtab );
                 sat.newNeed.insert( match.need.begin(), match.need.end() );
                 sat.cand->env = std::move( match.env );
 …
                 bindAssertion( assn.first, assn.second, sat.cand, match, sat.inferred );
                 return AssertionResult::Success;
+                return true;
+        }
 …
                 // for each current mutually-compatible set of assertions
                 for ( SatState & sat : sats ) {
+                        bool allowConversion = false;
                         // stop this branch if a better option is already found
                         auto it = thresholds.find( pruneKey( *sat.cand ) );
 …
                         for (unsigned resetCount = 0; ; ++resetCount) {
                                 ast::AssertionList next;
+                                resetTyVarRenaming();
                                 // make initial pass at matching assertions
                                 for ( auto & assn : sat.need ) {
-                                        resetTyVarRenaming();
                                         // fail early if any assertion is not satisfiable
+                                        auto result = satisfyAssertion( assn, sat, !next.empty() );
+                                        if ( result == AssertionResult::Fail ) {
+                                        if ( ! satisfyAssertion( assn, sat, allowConversion, !next.empty() ) ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
+                                // fail if nothing resolves
+                                else if (next.size() == sat.need.size()) {
+                                        if (allowConversion) {
                                                 Indenter tabs{ 3 };
                                                 std::ostringstream ss;
 …
                                                 print( ss, *sat.cand, ++tabs );
                                                 ss << (tabs-1) << "Could not satisfy assertion:\n";
                                                 ast::print( ss, assn.first, tabs );
+                                                ast::print( ss, next[0].first, tabs );
                                                 errors.emplace_back( ss.str() );
                                                 goto nextSat;
+                                        }
+                                        else if ( result == AssertionResult::Skip ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
+                                        else {
+                                                allowConversion = true;
+                                                continue;
+                                        }
+                                }
+                                allowConversion = false;
                                 sat.need = std::move(next);
+                        }
 …
                                                 sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
                                                 ast::AssertionSet{} /* need moved into satisfaction state */,
                                                 sat.cand->cost );
+                                                sat.cand->cost, sat.cand->cvtCost );
                                         ast::AssertionSet nextNewNeed{ sat.newNeed };
 …
                                         for ( DeferRef r : compat.assns ) {
                                                 AssnCandidate match = r.match;
                                                 // addToSymbolTable( match.have, nextSymtab );
+                                                addToSymbolTable( match.have, nextSymtab );
                                                 nextNewNeed.insert( match.need.begin(), match.need.end() );

src/ResolvExpr/Unify.cc

-              rc84dd61
+              r0b0a285
                 env.apply( newSecond );
                 // findOpenVars( newFirst, open, closed, need, have, FirstClosed );
                 findOpenVars( newSecond, open, closed, need, have, newEnv, FirstOpen );
+                findOpenVars( newFirst, open, closed, need, have, FirstClosed );
+                findOpenVars( newSecond, open, closed, need, have, FirstOpen );
                 return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden() );
 …
                         // check that the other type is compatible and named the same
                         auto otherInst = dynamic_cast< const XInstType * >( other );
+                        if (otherInst && inst->name == otherInst->name)
+                                this->result = otherInst;
+                        if (otherInst && inst->name == otherInst->name) this->result = otherInst;
                         return otherInst;
+                }
 …
                 void postvisit( const ast::TypeInstType * typeInst ) {
+                        // assert( open.find( *typeInst ) == open.end() );
+                        auto otherInst = dynamic_cast< const ast::TypeInstType * >( type2 );
+                        if (otherInst && typeInst->name == otherInst->name)
+                                this->result = otherInst;
+                        // return otherInst;
+                        assert( open.find( *typeInst ) == open.end() );
+                        handleRefType( typeInst, type2 );
+                }
 …
         ) {
                 ast::OpenVarSet closed;
                 // findOpenVars( type1, open, closed, need, have, FirstClosed );
                 findOpenVars( type2, open, closed, need, have, env, FirstOpen );
+                findOpenVars( type1, open, closed, need, have, FirstClosed );
+                findOpenVars( type2, open, closed, need, have, FirstOpen );
                 return unifyInexact(
                         type1, type2, env, need, have, open, WidenMode{ true, true }, common );
 …
                         entry1 = var1 ? open.find( *var1 ) : open.end(),
                         entry2 = var2 ? open.find( *var2 ) : open.end();
+                // bool isopen1 = entry1 != open.end();
+                // bool isopen2 = entry2 != open.end();
+                bool isopen1 = var1 && env.lookup(*var1);
+                bool isopen2 = var2 && env.lookup(*var2);
+                /*
+                bool isopen1 = entry1 != open.end();
+                bool isopen2 = entry2 != open.end();
                 if ( isopen1 && isopen2 ) {
                         if ( entry1->second.kind != entry2->second.kind ) return false;
 …
                         return env.bindVar( var1, type2, entry1->second, need, have, open, widen );
                 } else if ( isopen2 ) {
+                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
+                } */
+                if ( isopen1 && isopen2 ) {
+                        if ( var1->base->kind != var2->base->kind ) return false;
+                        return env.bindVarToVar(
+                                var1, var2, ast::TypeData{ var1->base->kind, var1->base->sized||var2->base->sized }, need, have,
+                                open, widen );
+                } else if ( isopen1 ) {
+                        return env.bindVar( var1, type2, ast::TypeData{var1->base}, need, have, open, widen );
+                } else if ( isopen2 ) {
+                        return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen );
+                }else {
+                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen );
+                } else {
                         return ast::Pass<Unify_new>::read(
                                 type1, type2, env, need, have, open, widen );
+                }
+        }

src/SynTree/Expression.cc

rc84dd61	r0b0a285
267	267	}
268	268
269		CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated~~, CastKind kind ) : arg(arg), isGenerated( isGenerated ), kind( kin~~d ) {
	269	CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
270	270	set_result(toType);
271	271	}
272	272
273		CastExpr::CastExpr( Expression * arg, bool isGenerated~~, CastKind kind ) : arg(arg), isGenerated( isGenerated ), kind( kin~~d ) {
	273	CastExpr::CastExpr( Expression * arg, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
274	274	set_result( new VoidType( Type::Qualifiers() ) );
275	275	}
276	276
277		CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated )~~, kind( other.kind )~~ {
	277	CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
278	278	}
279	279

src/SynTree/Expression.h

-              rc84dd61
+              r0b0a285
         bool isGenerated = true;
+        enum CastKind {
+                Default, // C
+                Coerce, // reinterpret cast
+                Return  // overload selection
+        };
+        CastKind kind = Default;
+        CastExpr( Expression * arg, bool isGenerated = true, CastKind kind = Default );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true, CastKind kind = Default );
+        CastExpr( Expression * arg, bool isGenerated = true );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
         CastExpr( Expression * arg, void * ) = delete; // prevent accidentally passing pointers for isGenerated in the first constructor
         CastExpr( const CastExpr & other );

src/Tuples/TupleAssignment.cc

rc84dd61	r0b0a285
679	679
680	680	ResolvExpr::CandidateFinder finder( crntFinder.context, matcher->env );
681		~~finder.allowVoid = true;~~
682	681
683	682	try {

src/Validate/Autogen.cpp

-              rc84dd61
+              r0b0a285
 void FuncGenerator::produceDecl( const ast::FunctionDecl * decl ) {
         assert( nullptr != decl->stmts );
-        assert( decl->type_params.size() == getGenericParams( type ).size() );
         definitions.push_back( decl );
 …
                 decl->init = nullptr;
                 splice( assertions, decl->assertions );
                 oldToNew.emplace( old_param, decl );
+                oldToNew.emplace( std::make_pair( old_param, decl ) );
                 type_params.push_back( decl );
+        }
 …
         InitTweak::InitExpander_new srcParam( src );
         // Assign to destination.
         ast::MemberExpr * dstSelect = new ast::MemberExpr(
+        ast::Expr * dstSelect = new ast::MemberExpr(
                 location,
                 field,
 …
+                }
                 ast::MemberExpr * srcSelect = (srcParam) ? new ast::MemberExpr(
+                ast::Expr * srcSelect = (srcParam) ? new ast::MemberExpr(
                         location, field, new ast::VariableExpr( location, srcParam )
                 ) : nullptr;

src/Validate/GenericParameter.cpp

-              rc84dd61
+              r0b0a285
+}
+bool isSizedPolymorphic( const ast::AggregateDecl * decl ) {
+        for ( const auto & param : decl->params ) {
+                if ( param->sized ) return true;
+        }
+        return false;
+}
+struct ValidateGenericParamsCore :
+                public ast::WithCodeLocation, public ast::WithGuards {
+        // Generic parameter filling and checks:
+struct ValidateGenericParamsCore : public ast::WithCodeLocation {
         const ast::StructInstType * previsit( const ast::StructInstType * type ) {
                 assert( location );
 …
                 assert( location );
                 return validateGeneric( *location, type );
+        }
-        // Check parameter and bitfield combinations:
-        bool insideSized = false;
-        void previsit( const ast::StructDecl * decl ) {
-                if ( isSizedPolymorphic( decl ) && !insideSized ) {
-                        GuardValue( insideSized ) = true;
+                }
+        }
-        void previsit( const ast::UnionDecl * decl ) {
-                if ( isSizedPolymorphic( decl ) && !insideSized ) {
-                        GuardValue( insideSized ) = true;
+                }
+        }
-        void previsit( const ast::ObjectDecl * decl ) {
-                if ( insideSized && decl->bitfieldWidth ) {
-                        SemanticError( decl->location, decl,
-                                "Cannot have bitfields inside a sized polymorphic structure." );
+                }
+        }
 };

src/Validate/LinkReferenceToTypes.cpp

-              rc84dd61
+              r0b0a285
                 // Just linking in the node.
                 auto mut = ast::mutate( type );
                 mut->base = decl;
+                mut->base = const_cast<ast::EnumDecl *>( decl );
                 type = mut;
+        }
 …
                 // Just linking in the node.
                 auto mut = ast::mutate( type );
                 mut->base = decl;
+                mut->base = const_cast<ast::StructDecl *>( decl );
                 type = mut;
+        }
 …
                 // Just linking in the node.
                 auto mut = ast::mutate( type );
                 mut->base = decl;
+                mut->base = const_cast<ast::UnionDecl *>( decl );
                 type = mut;
+        }
 …
         // Just linking in the node.
         mut->base = decl;
+        mut->base = const_cast<ast::TraitDecl *>( decl );
         // Need to carry over the 'sized' status of each decl in the instance.
 …
+        }
+        // The following section
         ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );
         if ( fwds != forwardEnums.end() ) {

src/Virtual/VirtualDtor.cpp

-              rc84dd61
+              r0b0a285
             CompoundStmt * dtorBody = mutate( decl->stmts.get() );
             // Adds the following to the start of any actor/message dtor:
+            // Adds the following to the end of any actor/message dtor:
             //  __CFA_dtor_shutdown( this );
+            dtorBody->push_front(
+                new IfStmt( decl->location,
+                    new UntypedExpr (
+                        decl->location,
+                        new NameExpr( decl->location, "__CFA_dtor_shutdown" ),
+                        {
+                            new NameExpr( decl->location, decl->params.at(0)->name )
+                        }
+                    ),
+                    new ReturnStmt( decl->location, nullptr )
+                )
+            );
+            dtorBody->push_front( new ExprStmt(
+                decl->location,
+                                new UntypedExpr (
+                    decl->location,
+                                        new NameExpr( decl->location, "__CFA_dtor_shutdown" ),
+                                        {
+                        new NameExpr( decl->location, decl->params.at(0)->name )
+                                        }
+                                )
+                        ));
             return;
+        }

src/main.cc

-              rc84dd61
+              r0b0a285
 #include <list>                             // for list
 #include <string>                           // for char_traits, operator<<
+using namespace std;
 #include "AST/Convert.hpp"
 …
 #include "Virtual/VirtualDtor.hpp"           // for implementVirtDtors
-using namespace std;
 static void NewPass( const char * const name ) {
         Stats::Heap::newPass( name );
 …
                 PASS( "Fix Qualified Types", Validate::fixQualifiedTypes, transUnit );
+                PASS( "Hoist Struct", Validate::hoistStruct, transUnit );
                 PASS( "Eliminate Typedef", Validate::eliminateTypedef, transUnit );
-                PASS( "Hoist Struct", Validate::hoistStruct, transUnit );
                 PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
                 PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );

tests/.expect/mathX.arm64.txt

-              rc84dd61
+              r0b0a285
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = -128, ceiling(-66, 64) = -64
 ceiling(-128, -128) = -128, ceiling(-126, -128) = 0, ceiling(126, -128) = -128
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = -128, ceiling(-66, 64) = 0
+ceiling(-128, -128) = -128, ceiling(-126, -128) = -128, ceiling(126, -128) = 0
 unsigned char
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = -32768, ceiling(-16386, 16384) = -16384
 ceiling(-32768, -32768) = -32768, ceiling(-32766, -32768) = 0, ceiling(32766, -32768) = -32768
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = -32768, ceiling(-16386, 16384) = 0
+ceiling(-32768, -32768) = -32768, ceiling(-32766, -32768) = -32768, ceiling(32766, -32768) = 0
 unsigned short int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = -2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(-2147483648, -2147483648) = -2147483648, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = -2147483648
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = -1073741824, ceiling(-1073741826, 1073741824) = 0
+ceiling(-2147483648, -2147483648) = -2147483648, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = 0
 unsigned int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = -2147483648
 ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = -4294967296
 ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = -8589934592
 ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = -17179869184
 ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = -34359738368
 ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = -68719476736
 ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = -137438953472
 ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = -274877906944
 ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = -549755813888
 ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = -1099511627776
 ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = -2199023255552
 ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = -4398046511104
 ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = -8796093022208
 ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = -17592186044416
 ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = -35184372088832
 ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = -70368744177664
 ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = -140737488355328
 ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = -281474976710656
 ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = -562949953421312
 ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = -1125899906842624
 ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = -2251799813685248
 ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = -4503599627370496
 ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = -9007199254740992
 ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = -18014398509481984
 ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = -36028797018963968
 ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = -72057594037927936
 ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = -144115188075855872
 ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = -288230376151711744
 ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = -576460752303423488
 ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = -1152921504606846976
 ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = -2305843009213693952
 ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -9223372036854775808, ceiling(-4611686018427387906, 4611686018427387904) = -4611686018427387904
 ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = -9223372036854775808
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = 0
+ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = 0
+ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = 0
+ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = 0
+ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = 0
+ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = 0
+ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = 0
+ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = 0
+ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = 0
+ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = 0
+ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = 0
+ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = 0
+ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = 0
+ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = 0
+ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = 0
+ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = 0
+ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = 0
+ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = 0
+ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = 0
+ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = 0
+ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = 0
+ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = 0
+ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = 0
+ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = 0
+ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = 0
+ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = 0
+ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = 0
+ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = 0
+ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = 0
+ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = 0
+ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = 0
+ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = 0
+ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -4611686018427387904, ceiling(-4611686018427387906, 4611686018427387904) = 0
+ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = 0
 unsigned long int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = -2147483648
 ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = -4294967296
 ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = -8589934592
 ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = -17179869184
 ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = -34359738368
 ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = -68719476736
 ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = -137438953472
 ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = -274877906944
 ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = -549755813888
 ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = -1099511627776
 ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = -2199023255552
 ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = -4398046511104
 ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = -8796093022208
 ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = -17592186044416
 ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = -35184372088832
 ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = -70368744177664
 ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = -140737488355328
 ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = -281474976710656
 ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = -562949953421312
 ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = -1125899906842624
 ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = -2251799813685248
 ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = -4503599627370496
 ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = -9007199254740992
 ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = -18014398509481984
 ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = -36028797018963968
 ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = -72057594037927936
 ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = -144115188075855872
 ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = -288230376151711744
 ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = -576460752303423488
 ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = -1152921504606846976
 ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = -2305843009213693952
 ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -9223372036854775808, ceiling(-4611686018427387906, 4611686018427387904) = -4611686018427387904
 ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = -9223372036854775808
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = 0
+ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = 0
+ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = 0
+ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = 0
+ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = 0
+ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = 0
+ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = 0
+ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = 0
+ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = 0
+ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = 0
+ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = 0
+ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = 0
+ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = 0
+ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = 0
+ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = 0
+ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = 0
+ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = 0
+ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = 0
+ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = 0
+ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = 0
+ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = 0
+ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = 0
+ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = 0
+ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = 0
+ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = 0
+ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = 0
+ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = 0
+ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = 0
+ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = 0
+ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = 0
+ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = 0
+ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = 0
+ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -4611686018427387904, ceiling(-4611686018427387906, 4611686018427387904) = 0
+ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = 0
 unsigned long long int

tests/.expect/mathX.x64.txt

-              rc84dd61
+              r0b0a285
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = -128, ceiling(-66, 64) = -64
 ceiling(-128, -128) = -128, ceiling(-126, -128) = 0, ceiling(126, -128) = -128
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = -128, ceiling(-66, 64) = 0
+ceiling(-128, -128) = -128, ceiling(-126, -128) = -128, ceiling(126, -128) = 0
 unsigned char
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = -32768, ceiling(-16386, 16384) = -16384
 ceiling(-32768, -32768) = -32768, ceiling(-32766, -32768) = 0, ceiling(32766, -32768) = -32768
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = -32768, ceiling(-16386, 16384) = 0
+ceiling(-32768, -32768) = -32768, ceiling(-32766, -32768) = -32768, ceiling(32766, -32768) = 0
 unsigned short int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = -2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(-2147483648, -2147483648) = -2147483648, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = -2147483648
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = -1073741824, ceiling(-1073741826, 1073741824) = 0
+ceiling(-2147483648, -2147483648) = -2147483648, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = 0
 unsigned int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = -2147483648
 ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = -4294967296
 ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = -8589934592
 ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = -17179869184
 ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = -34359738368
 ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = -68719476736
 ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = -137438953472
 ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = -274877906944
 ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = -549755813888
 ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = -1099511627776
 ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = -2199023255552
 ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = -4398046511104
 ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = -8796093022208
 ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = -17592186044416
 ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = -35184372088832
 ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = -70368744177664
 ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = -140737488355328
 ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = -281474976710656
 ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = -562949953421312
 ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = -1125899906842624
 ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = -2251799813685248
 ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = -4503599627370496
 ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = -9007199254740992
 ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = -18014398509481984
 ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = -36028797018963968
 ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = -72057594037927936
 ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = -144115188075855872
 ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = -288230376151711744
 ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = -576460752303423488
 ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = -1152921504606846976
 ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = -2305843009213693952
 ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -9223372036854775808, ceiling(-4611686018427387906, 4611686018427387904) = -4611686018427387904
 ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = -9223372036854775808
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = 0
+ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = 0
+ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = 0
+ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = 0
+ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = 0
+ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = 0
+ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = 0
+ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = 0
+ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = 0
+ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = 0
+ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = 0
+ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = 0
+ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = 0
+ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = 0
+ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = 0
+ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = 0
+ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = 0
+ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = 0
+ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = 0
+ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = 0
+ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = 0
+ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = 0
+ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = 0
+ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = 0
+ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = 0
+ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = 0
+ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = 0
+ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = 0
+ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = 0
+ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = 0
+ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = 0
+ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = 0
+ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -4611686018427387904, ceiling(-4611686018427387906, 4611686018427387904) = 0
+ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = 0
 unsigned long int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = -2147483648
 ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = -4294967296
 ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = -8589934592
 ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = -17179869184
 ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = -34359738368
 ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = -68719476736
 ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = -137438953472
 ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = -274877906944
 ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = -549755813888
 ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = -1099511627776
 ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = -2199023255552
 ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = -4398046511104
 ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = -8796093022208
 ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = -17592186044416
 ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = -35184372088832
 ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = -70368744177664
 ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = -140737488355328
 ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = -281474976710656
 ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = -562949953421312
 ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = -1125899906842624
 ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = -2251799813685248
 ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = -4503599627370496
 ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = -9007199254740992
 ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = -18014398509481984
 ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = -36028797018963968
 ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = -72057594037927936
 ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = -144115188075855872
 ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = -288230376151711744
 ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = -576460752303423488
 ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = -1152921504606846976
 ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = -2305843009213693952
 ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -9223372036854775808, ceiling(-4611686018427387906, 4611686018427387904) = -4611686018427387904
 ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = -9223372036854775808
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = 0
+ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = 0
+ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = 0
+ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = 0
+ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = 0
+ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = 0
+ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = 0
+ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = 0
+ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = 0
+ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = 0
+ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = 0
+ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = 0
+ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = 0
+ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = 0
+ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = 0
+ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = 0
+ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = 0
+ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = 0
+ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = 0
+ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = 0
+ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = 0
+ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = 0
+ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = 0
+ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = 0
+ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = 0
+ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = 0
+ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = 0
+ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = 0
+ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = 0
+ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = 0
+ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = 0
+ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = 0
+ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -4611686018427387904, ceiling(-4611686018427387906, 4611686018427387904) = 0
+ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = 0
 unsigned long long int

tests/.expect/mathX.x86.txt

-              rc84dd61
+              r0b0a285
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = -128, ceiling(-66, 64) = -64
 ceiling(-128, -128) = -128, ceiling(-126, -128) = 0, ceiling(126, -128) = -128
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = -128, ceiling(-66, 64) = 0
+ceiling(-128, -128) = -128, ceiling(-126, -128) = -128, ceiling(126, -128) = 0
 unsigned char
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = -32768, ceiling(-16386, 16384) = -16384
 ceiling(-32768, -32768) = -32768, ceiling(-32766, -32768) = 0, ceiling(32766, -32768) = -32768
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = -32768, ceiling(-16386, 16384) = 0
+ceiling(-32768, -32768) = -32768, ceiling(-32766, -32768) = -32768, ceiling(32766, -32768) = 0
 unsigned short int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = -2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(-2147483648, -2147483648) = -2147483648, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = -2147483648
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = -1073741824, ceiling(-1073741826, 1073741824) = 0
+ceiling(-2147483648, -2147483648) = -2147483648, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = 0
 unsigned int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = -2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(-2147483648, -2147483648) = -2147483648, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = -2147483648
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = -1073741824, ceiling(-1073741826, 1073741824) = 0
+ceiling(-2147483648, -2147483648) = -2147483648, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = 0
 unsigned long int
 …
 ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3
 ceiling(2, 2) = 2, ceiling(4, 2) = 4, ceiling(-4, 2) = -4
 ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = -4
 ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = -8
 ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = -16
 ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = -32
 ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = -64
 ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = -128
 ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = -256
 ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = -512
 ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = -1024
 ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = -2048
 ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = -4096
 ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = -8192
 ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = -16384
 ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = -32768
 ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = -65536
 ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = -131072
 ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = -262144
 ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = -524288
 ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = -1048576
 ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = -2097152
 ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = -4194304
 ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = -8388608
 ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = -16777216
 ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = -33554432
 ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = -67108864
 ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = -134217728
 ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = -268435456
 ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = -536870912
 ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = -1073741824
 ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = -2147483648
 ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = -4294967296
 ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = -8589934592
 ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = -17179869184
 ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = -34359738368
 ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = -68719476736
 ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = -137438953472
 ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = -274877906944
 ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = -549755813888
 ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = -1099511627776
 ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = -2199023255552
 ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = -4398046511104
 ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = -8796093022208
 ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = -17592186044416
 ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = -35184372088832
 ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = -70368744177664
 ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = -140737488355328
 ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = -281474976710656
 ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = -562949953421312
 ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = -1125899906842624
 ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = -2251799813685248
 ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = -4503599627370496
 ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = -9007199254740992
 ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = -18014398509481984
 ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = -36028797018963968
 ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = -72057594037927936
 ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = -144115188075855872
 ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = -288230376151711744
 ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = -576460752303423488
 ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = -1152921504606846976
 ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = -2305843009213693952
 ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -9223372036854775808, ceiling(-4611686018427387906, 4611686018427387904) = -4611686018427387904
 ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = -9223372036854775808
+ceiling(4, 4) = 4, ceiling(6, 4) = 8, ceiling(-6, 4) = 0
+ceiling(8, 8) = 8, ceiling(10, 8) = 16, ceiling(-10, 8) = 0
+ceiling(16, 16) = 16, ceiling(18, 16) = 32, ceiling(-18, 16) = 0
+ceiling(32, 32) = 32, ceiling(34, 32) = 64, ceiling(-34, 32) = 0
+ceiling(64, 64) = 64, ceiling(66, 64) = 128, ceiling(-66, 64) = 0
+ceiling(128, 128) = 128, ceiling(130, 128) = 256, ceiling(-130, 128) = 0
+ceiling(256, 256) = 256, ceiling(258, 256) = 512, ceiling(-258, 256) = 0
+ceiling(512, 512) = 512, ceiling(514, 512) = 1024, ceiling(-514, 512) = 0
+ceiling(1024, 1024) = 1024, ceiling(1026, 1024) = 2048, ceiling(-1026, 1024) = 0
+ceiling(2048, 2048) = 2048, ceiling(2050, 2048) = 4096, ceiling(-2050, 2048) = 0
+ceiling(4096, 4096) = 4096, ceiling(4098, 4096) = 8192, ceiling(-4098, 4096) = 0
+ceiling(8192, 8192) = 8192, ceiling(8194, 8192) = 16384, ceiling(-8194, 8192) = 0
+ceiling(16384, 16384) = 16384, ceiling(16386, 16384) = 32768, ceiling(-16386, 16384) = 0
+ceiling(32768, 32768) = 32768, ceiling(32770, 32768) = 65536, ceiling(-32770, 32768) = 0
+ceiling(65536, 65536) = 65536, ceiling(65538, 65536) = 131072, ceiling(-65538, 65536) = 0
+ceiling(131072, 131072) = 131072, ceiling(131074, 131072) = 262144, ceiling(-131074, 131072) = 0
+ceiling(262144, 262144) = 262144, ceiling(262146, 262144) = 524288, ceiling(-262146, 262144) = 0
+ceiling(524288, 524288) = 524288, ceiling(524290, 524288) = 1048576, ceiling(-524290, 524288) = 0
+ceiling(1048576, 1048576) = 1048576, ceiling(1048578, 1048576) = 2097152, ceiling(-1048578, 1048576) = 0
+ceiling(2097152, 2097152) = 2097152, ceiling(2097154, 2097152) = 4194304, ceiling(-2097154, 2097152) = 0
+ceiling(4194304, 4194304) = 4194304, ceiling(4194306, 4194304) = 8388608, ceiling(-4194306, 4194304) = 0
+ceiling(8388608, 8388608) = 8388608, ceiling(8388610, 8388608) = 16777216, ceiling(-8388610, 8388608) = 0
+ceiling(16777216, 16777216) = 16777216, ceiling(16777218, 16777216) = 33554432, ceiling(-16777218, 16777216) = 0
+ceiling(33554432, 33554432) = 33554432, ceiling(33554434, 33554432) = 67108864, ceiling(-33554434, 33554432) = 0
+ceiling(67108864, 67108864) = 67108864, ceiling(67108866, 67108864) = 134217728, ceiling(-67108866, 67108864) = 0
+ceiling(134217728, 134217728) = 134217728, ceiling(134217730, 134217728) = 268435456, ceiling(-134217730, 134217728) = 0
+ceiling(268435456, 268435456) = 268435456, ceiling(268435458, 268435456) = 536870912, ceiling(-268435458, 268435456) = 0
+ceiling(536870912, 536870912) = 536870912, ceiling(536870914, 536870912) = 1073741824, ceiling(-536870914, 536870912) = 0
+ceiling(1073741824, 1073741824) = 1073741824, ceiling(1073741826, 1073741824) = 2147483648, ceiling(-1073741826, 1073741824) = 0
+ceiling(2147483648, 2147483648) = 2147483648, ceiling(2147483650, 2147483648) = 4294967296, ceiling(-2147483650, 2147483648) = 0
+ceiling(4294967296, 4294967296) = 4294967296, ceiling(4294967298, 4294967296) = 8589934592, ceiling(-4294967298, 4294967296) = 0
+ceiling(8589934592, 8589934592) = 8589934592, ceiling(8589934594, 8589934592) = 17179869184, ceiling(-8589934594, 8589934592) = 0
+ceiling(17179869184, 17179869184) = 17179869184, ceiling(17179869186, 17179869184) = 34359738368, ceiling(-17179869186, 17179869184) = 0
+ceiling(34359738368, 34359738368) = 34359738368, ceiling(34359738370, 34359738368) = 68719476736, ceiling(-34359738370, 34359738368) = 0
+ceiling(68719476736, 68719476736) = 68719476736, ceiling(68719476738, 68719476736) = 137438953472, ceiling(-68719476738, 68719476736) = 0
+ceiling(137438953472, 137438953472) = 137438953472, ceiling(137438953474, 137438953472) = 274877906944, ceiling(-137438953474, 137438953472) = 0
+ceiling(274877906944, 274877906944) = 274877906944, ceiling(274877906946, 274877906944) = 549755813888, ceiling(-274877906946, 274877906944) = 0
+ceiling(549755813888, 549755813888) = 549755813888, ceiling(549755813890, 549755813888) = 1099511627776, ceiling(-549755813890, 549755813888) = 0
+ceiling(1099511627776, 1099511627776) = 1099511627776, ceiling(1099511627778, 1099511627776) = 2199023255552, ceiling(-1099511627778, 1099511627776) = 0
+ceiling(2199023255552, 2199023255552) = 2199023255552, ceiling(2199023255554, 2199023255552) = 4398046511104, ceiling(-2199023255554, 2199023255552) = 0
+ceiling(4398046511104, 4398046511104) = 4398046511104, ceiling(4398046511106, 4398046511104) = 8796093022208, ceiling(-4398046511106, 4398046511104) = 0
+ceiling(8796093022208, 8796093022208) = 8796093022208, ceiling(8796093022210, 8796093022208) = 17592186044416, ceiling(-8796093022210, 8796093022208) = 0
+ceiling(17592186044416, 17592186044416) = 17592186044416, ceiling(17592186044418, 17592186044416) = 35184372088832, ceiling(-17592186044418, 17592186044416) = 0
+ceiling(35184372088832, 35184372088832) = 35184372088832, ceiling(35184372088834, 35184372088832) = 70368744177664, ceiling(-35184372088834, 35184372088832) = 0
+ceiling(70368744177664, 70368744177664) = 70368744177664, ceiling(70368744177666, 70368744177664) = 140737488355328, ceiling(-70368744177666, 70368744177664) = 0
+ceiling(140737488355328, 140737488355328) = 140737488355328, ceiling(140737488355330, 140737488355328) = 281474976710656, ceiling(-140737488355330, 140737488355328) = 0
+ceiling(281474976710656, 281474976710656) = 281474976710656, ceiling(281474976710658, 281474976710656) = 562949953421312, ceiling(-281474976710658, 281474976710656) = 0
+ceiling(562949953421312, 562949953421312) = 562949953421312, ceiling(562949953421314, 562949953421312) = 1125899906842624, ceiling(-562949953421314, 562949953421312) = 0
+ceiling(1125899906842624, 1125899906842624) = 1125899906842624, ceiling(1125899906842626, 1125899906842624) = 2251799813685248, ceiling(-1125899906842626, 1125899906842624) = 0
+ceiling(2251799813685248, 2251799813685248) = 2251799813685248, ceiling(2251799813685250, 2251799813685248) = 4503599627370496, ceiling(-2251799813685250, 2251799813685248) = 0
+ceiling(4503599627370496, 4503599627370496) = 4503599627370496, ceiling(4503599627370498, 4503599627370496) = 9007199254740992, ceiling(-4503599627370498, 4503599627370496) = 0
+ceiling(9007199254740992, 9007199254740992) = 9007199254740992, ceiling(9007199254740994, 9007199254740992) = 18014398509481984, ceiling(-9007199254740994, 9007199254740992) = 0
+ceiling(18014398509481984, 18014398509481984) = 18014398509481984, ceiling(18014398509481986, 18014398509481984) = 36028797018963968, ceiling(-18014398509481986, 18014398509481984) = 0
+ceiling(36028797018963968, 36028797018963968) = 36028797018963968, ceiling(36028797018963970, 36028797018963968) = 72057594037927936, ceiling(-36028797018963970, 36028797018963968) = 0
+ceiling(72057594037927936, 72057594037927936) = 72057594037927936, ceiling(72057594037927938, 72057594037927936) = 144115188075855872, ceiling(-72057594037927938, 72057594037927936) = 0
+ceiling(144115188075855872, 144115188075855872) = 144115188075855872, ceiling(144115188075855874, 144115188075855872) = 288230376151711744, ceiling(-144115188075855874, 144115188075855872) = 0
+ceiling(288230376151711744, 288230376151711744) = 288230376151711744, ceiling(288230376151711746, 288230376151711744) = 576460752303423488, ceiling(-288230376151711746, 288230376151711744) = 0
+ceiling(576460752303423488, 576460752303423488) = 576460752303423488, ceiling(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling(-576460752303423490, 576460752303423488) = 0
+ceiling(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling(-1152921504606846978, 1152921504606846976) = 0
+ceiling(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling(-2305843009213693954, 2305843009213693952) = 0
+ceiling(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling(4611686018427387906, 4611686018427387904) = -4611686018427387904, ceiling(-4611686018427387906, 4611686018427387904) = 0
+ceiling(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = 0
 unsigned long long int

tests/Makefile.am

-              rc84dd61
+              r0b0a285
         concurrency/clib.c \
         concurrency/unified_locking/mutex_test.hfa \
+        concurrency/channels/parallel_harness.hfa \
+        array-container/dimexpr-match.hfa \
+        array-container/dimexpr-match-detail.sh
+        concurrency/channels/parallel_harness.hfa
 dist-hook:
 …
 # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
 all-local : # This name is important to automake and implies the default build target.
         @+${TEST_PY} --debug=${debug} --install=${installed} ${ARCHIVE_ERRORS} ${TIMEOUT} ${GLOBAL_TIMEOUT} ${ARCH} --all
+        @+${TEST_PY} --debug=${debug} --install=${installed} --invariant ${ARCHIVE_ERRORS} ${TIMEOUT} ${GLOBAL_TIMEOUT} ${ARCH} --all
 tests : all-local # synonym
 …
         -cp ${test} ${abspath ${@}}
-array-container/dimexpr-match-c-ERRS : array-container/dimexpr-match-c.cfa
-        ${CFACOMPILE_SYNTAX} -DERRS
-        -cp ${test} ${abspath ${@}}
-array-container/dimexpr-match-cfa-ERRS : array-container/dimexpr-match-cfa.cfa
-        ${CFACOMPILE_SYNTAX} -DERRS
-        -cp ${test} ${abspath ${@}}
 alloc-ERROR : alloc.cfa ${CFACCBIN}
         ${CFACOMPILE_SYNTAX} -DERR1

tests/collections/vector-demo.cfa

rc84dd61	r0b0a285
143	143	assert( v`capacity > 5 && v`length == 5 );
144	144
145		v[2] = -0.1f; // v is [0.0, 98.6, -0.1, 0.2, 0.3]; iter at -0.1, where only the new memory had that change
	145	v[2] = -0.1; // v is [0.0, 98.6, -0.1, 0.2, 0.3]; iter at -0.1, where only the new memory had that change
146	146
147	147	float val3 = iter`val;

tests/concurrency/actors/.expect/inherit.txt

rc84dd61	r0b0a285
4	4	A
5	5	A
6		A
7		A
8	6	Finished

tests/concurrency/actors/dynamic.cfa

-              rc84dd61
+              r0b0a285
     derived_actor * d_actor = alloc();
     (*d_actor){};
     *d_actor | *d_msg;
+    *d_actor << *d_msg;
     return Delete;
+}
 …
     derived_actor * d_actor = alloc();
     (*d_actor){};
     *d_actor | *d_msg;
+    *d_actor << *d_msg;
     printf("stopping\n");

tests/concurrency/actors/executor.cfa

-              rc84dd61
+              r0b0a285
     if ( recs % Batch == 0 ) {
         for ( i; Batch ) {
             gstart[sends % Set] | shared_msg;
+            gstart[sends % Set] << shared_msg;
             sends += 1;
+        }
 …
         for ( i; Actors ) {
                 actors[i] | shared_msg;
+                actors[i] << shared_msg;
         } // for

tests/concurrency/actors/inherit.cfa

-              rc84dd61
+              r0b0a285
 struct Server { inline actor; };
+struct Server2 { inline Server; int b; };
+struct D_msg { int a; inline message; };
+struct D_msg2 { inline D_msg; };
-struct Server2 { inline Server; int b; };
 void ^?{}( Server2 & this ) { mutex(sout) sout | 'A'; }
-struct D_msg { int a; inline message; };
 void ?{}( D_msg & this ) { set_allocation( this, Delete ); }
 void ^?{}( D_msg & this ) { mutex(sout) sout | 'A'; }
-struct D_msg2 { inline D_msg; };
 allocation handle() {
 …
         D_msg * dm = alloc();
         (*dm){};
+        D_msg2 * dm2 = alloc();
+        (*dm2){};
+        D_msg2 dm2;
         Server2 * s = alloc();
         (*s){};
         Server2 * s2 = alloc();
         (*s2){};
         *s | *dm;
         *s2 | *dm2;
+        *s << *dm;
+        *s2 << dm2;
         stop_actor_system();
+    }
 …
         D_msg * dm = alloc();
         (*dm){};
+        D_msg2 * dm2 = alloc();
+        (*dm2){};
+        s[0] | *dm;
+        s[1] | *dm2;
+        D_msg2 dm2;
+        s[0] << *dm;
+        s[1] << dm2;
         stop_actor_system();
+    }

tests/concurrency/actors/matrix.cfa

rc84dd61	r0b0a285
105	105
106	106	for ( unsigned int r = 0; r < xr; r += 1 ) {
107		actors[r] \| messages[r];
	107	actors[r] << messages[r];
108	108	} // for
109	109

tests/concurrency/actors/pingpong.cfa

-              rc84dd61
+              r0b0a285
     allocation retval = Nodelete;
     if ( msg.count == times ) retval = Finished;
     *po | msg;
+    *po << msg;
     return retval;
+}
 …
     allocation retval = Nodelete;
     if ( msg.count == times ) retval = Finished;
     *pi | msg;
+    *pi << msg;
     return retval;
+}
 …
     pi = &pi_actor;
     p_msg m;
     pi_actor | m;
+    pi_actor << m;
     stop_actor_system();

tests/concurrency/actors/poison.cfa

-              rc84dd61
+              r0b0a285
         Server s[10];
         for ( i; 10 ) {
             s[i] | finished_msg;
+            s[i] << finished_msg;
+        }
         stop_actor_system();
 …
             Server * s = alloc();
             (*s){};
             (*s) | delete_msg;
+            (*s) << delete_msg;
+        }
         stop_actor_system();
 …
         Server s[10];
         for ( i; 10 )
             s[i] | destroy_msg;
+            s[i] << destroy_msg;
         stop_actor_system();
         for ( i; 10 )

tests/concurrency/actors/static.cfa

-              rc84dd61
+              r0b0a285
+    }
     msg.cnt++;
     receiver | msg;
+    receiver << msg;
     return Nodelete;
+}
 …
     derived_actor actor;
     actor | msg;
+    actor << msg;
     printf("stopping\n");

tests/concurrency/actors/types.cfa

-              rc84dd61
+              r0b0a285
     b.num = 1;
     c.num = 2;
     a | b | c;
+    a << b << c;
     stop_actor_system();
 …
     d_msg d_ac2_msg;
     d_ac2_msg.num = 3;
     d_ac2_0 | d_ac2_msg;
     d_ac2_1 | d_ac2_msg;
+    d_ac2_0 << d_ac2_msg;
+    d_ac2_1 << d_ac2_msg;
     stop_actor_system();
 …
         d_msg d_ac23_msg;
         d_ac23_msg.num = 4;
         d_ac3_0 | d_ac23_msg;
         d_ac2_2 | d_ac23_msg;
+        d_ac3_0 << d_ac23_msg;
+        d_ac2_2 << d_ac23_msg;
         stop_actor_system();
     } // RAII to clean up executor
 …
         b1.num = -1;
         c2.num = 5;
         a3 | b1 | c2;
+        a3 << b1 << c2;
         stop_actor_system();
     } // RAII to clean up executor
 …
         b1.num = -1;
         c2.num = 5;
         a4 | b1 | c2;
+        a4 << b1 << c2;
         stop_actor_system();
     } // RAII to clean up executor

tests/coroutine/devicedriver.cfa

-              rc84dd61
+              r0b0a285
 // Created On       : Sat Mar 16 15:30:34 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun 17 09:11:56 2023
 // Update Count     : 94
+// Last Modified On : Sat Apr 20 09:07:19 2019
+// Update Count     : 90
 //
 …
 enum Status { CONT, MSG, ESTX, ELNTH, ECRC };
 coroutine Driver {
         Status status;
 …
 }; // Driver
+void ?{}( Driver & d, char * m ) { d.msg = m; }                 // constructor
+Status next( Driver & d, char b ) with( d ) {                   // called by interrupt handler
+        byte = b; resume( d ); return status;                           // resume coroutine at last suspend
+void ?{}( Driver & d, char * m ) { d.msg = m; }
+Status next( Driver & d, char b ) with( d ) {
+        byte = b; resume( d ); return status;
 } // next
 …
           if ( eof( sin ) ) break eof;                                          // eof ?
                 choose( next( driver, byte ) ) {                                // analyse character
+                  case CONT: ;
+                  case MSG: sout | "msg:" | msg;
+                  case ESTX: sout | "STX in message";
+                  case ELNTH: sout | "message too long";
+                  case ECRC: sout | "CRC failure";
+                  case MSG:
+                        sout | "msg:" | msg;
+                  case ESTX:
+                        sout | "STX in message";
+                  case ELNTH:
+                        sout | "message too long";
+                  case ECRC:
+                        sout | "CRC failure";
+                  default: ;
                 } // choose
         } // for
 …
 // Local Variables: //
+// tab-width: 4 //
 // compile-command: "cfa -g -Wall -Wextra devicedriver.cfa" //
 // End: //

tests/io/manipulatorsInput.cfa

-              rc84dd61
+              r0b0a285
 // Created On       : Sat Jun  8 17:58:54 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jun 17 07:56:02 2023
 // Update Count     : 48
+// Last Modified On : Wed Jul 15 15:56:03 2020
+// Update Count     : 47
 //
 …
                 sin | ignore( wdi( 8, ldc ) );                  sout | ldc;
+        }
         #if defined( __SIZEOF_INT128__ )
+#if defined( __SIZEOF_INT128__ )
+        {
                 int128 val;
 …
+                }
+        }
         #endif // __SIZEOF_INT128__
+#endif // __SIZEOF_INT128__
 } // main

tests/pybin/settings.py

rc84dd61	r0b0a285
141	141	all_install = [Install(o) for o in list(dict.fromkeys(options.install))]
142	142	archive = os.path.abspath(os.path.join(original_path, options.archive_errors)) if options.archive_errors else None
143		invariant = options.~~no_~~invariant
	143	invariant = options.invariant
144	144	continue_ = options.continue_
145	145	dry_run = options.dry_run # must be called before tools.config_hash()

tests/test.py

-              rc84dd61
+              r0b0a285
         parser.add_argument('--install', help='Run all tests based on installed binaries or tree binaries', type=comma_separated(yes_no), default='no')
         parser.add_argument('--continue', help='When multiple specifications are passed (debug/install/arch), sets whether or not to continue if the last specification failed', type=yes_no, default='yes', dest='continue_')
+        parser.add_argument('--invariant', help='Tell the compiler to check invariants.', action='store_true')
+        parser.add_argument('--no-invariant', help='Tell the compiler not to check invariants.', action='store_false')
+        parser.add_argument('--invariant', help='Tell the compiler to check invariants while running.', action='store_true')
         parser.add_argument('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=180)
         parser.add_argument('--global-timeout', help='Maximum cumulative duration in seconds after the ALL tests are considered to have timed out', type=int, default=7200)

Context Navigation

Changes in / [c84dd61:0b0a285]

Legend:

Download in other formats: