Index: benchmark/io/readv.cfa =================================================================== --- benchmark/io/readv.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ benchmark/io/readv.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,169 @@ +#include +#include +#include + +extern "C" { + #include + #include + #include + #include +} + +#include + +#include +#include +#include +#include + +extern bool traceHeapOn(); +extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags); + +int fd; +volatile bool run = false; +volatile size_t count = 0; + +unsigned long int buflen = 50; + +cluster * the_cluster; + +thread Reader {}; +void ?{}( Reader & this ) { + ((thread&)this){ "Reader Thread", *the_cluster }; +} + +struct my_processor { + processor p; +}; + +void ?{}( my_processor & this ) { + (this.p){ "I/O Processor", *the_cluster }; +} + +void main( Reader & ) { + while(!__atomic_load_n(&run, __ATOMIC_RELAXED)) yield(); + + char data[buflen]; + struct iovec iov = { data, buflen }; + + while(__atomic_load_n(&run, __ATOMIC_RELAXED)) { + int r = cfa_preadv2(fd, &iov, 1, 0, 0); + if(r < 0) abort("%s\n", strerror(-r)); + + __atomic_fetch_add( &count, 1, __ATOMIC_SEQ_CST ); + } +} + +int main(int argc, char * argv[]) { + double duration = 5.0; + unsigned long int nthreads = 2; + unsigned long int nprocs = 1; + int flags = 0; + + arg_loop: + for(;;) { + static struct option options[] = { + {"duration", required_argument, 0, 'd'}, + {"nthreads", required_argument, 0, 't'}, + {"nprocs", required_argument, 0, 'p'}, + {"bufsize", required_argument, 0, 'b'}, + {"userthread", no_argument , 0, 'u'}, + {0, 0, 0, 0} + }; + + int idx = 0; + int opt = getopt_long(argc, argv, "d:t:p:b:u", options, &idx); + + const char * arg = optarg ? optarg : ""; + char * end; + switch(opt) { + // Exit Case + case -1: + break arg_loop; + // Numeric Arguments + case 'd': + duration = strtod(arg, &end); + if(*end != '\0') { + fprintf(stderr, "Duration must be a valid double, was %s\n", arg); + goto usage; + } + break; + case 't': + nthreads = strtoul(arg, &end, 10); + if(*end != '\0' || nthreads < 1) { + fprintf(stderr, "Number of threads must be a positive integer, was %s\n", arg); + goto usage; + } + break; + case 'p': + nprocs = strtoul(arg, &end, 10); + if(*end != '\0' || nprocs < 1) { + fprintf(stderr, "Number of processors must be a positive integer, was %s\n", arg); + goto usage; + } + break; + case 'b': + buflen = strtoul(arg, &end, 10); + if(*end != '\0' && buflen < 10) { + fprintf(stderr, "Buffer size must be at least 10, was %s\n", arg); + goto usage; + } + break; + case 'u': + flags |= CFA_CLUSTER_IO_POLLER_USER_THREAD; + break; + // Other cases + default: /* ? */ + fprintf(stderr, "%d\n", opt); + usage: + fprintf(stderr, "Usage: %s : [options]\n", argv[0]); + fprintf(stderr, "\n"); + fprintf(stderr, " -d, --duration=DURATION Duration of the experiment, in seconds\n"); + fprintf(stderr, " -t, --nthreads=NTHREADS Number of user threads\n"); + fprintf(stderr, " -p, --nprocs=NPROCS Number of kernel threads\n"); + fprintf(stderr, " -b, --buflen=SIZE Number of bytes to read per request\n"); + exit(EXIT_FAILURE); + } + } + + fd = open(__FILE__, 0); + if(fd < 0) { + fprintf(stderr, "Could not open source file\n"); + exit(EXIT_FAILURE); + } + + printf("Running %lu threads, reading %lu bytes each, over %lu processors for %lf seconds\n", nthreads, buflen, nprocs, duration); + + { + Time start, end; + cluster cl = { "IO Cluster", flags }; + the_cluster = &cl; + #if !defined(__CFA_NO_STATISTICS__) + print_stats_at_exit( cl ); + #endif + { + my_processor procs[nprocs]; + { + Reader threads[nthreads]; + + printf("Starting\n"); + start = getTime(); + run = true; + do { + sleep(500`ms); + end = getTime(); + } while( (end - start) < duration`s ); + run = false; + end = getTime(); + printf("Done\n"); + } + } + printf("Took %'ld ms\n", (end - start)`ms); + printf("Total reads : %'15zu\n", count); + printf("Reads per second : %'18.2lf\n", ((double)count) / (end - start)`s); + printf("Total read size : %'15zu\n", buflen * count); + printf("Bytes per second : %'18.2lf\n", ((double)count * buflen) / (end - start)`s); + } + + close(fd); +} Index: doc/bibliography/pl.bib =================================================================== --- doc/bibliography/pl.bib (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/bibliography/pl.bib (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -4524,4 +4524,13 @@ } +@misc{libfibre, + key = {libfibre}, + author = {Martin Karsten}, + title = {{libfibre:~User-Level Threading Runtime}}, + howpublished= {\href{https://git.uwaterloo.ca/mkarsten/libfibre} + {https://\-git.uwaterloo.ca/\-mkarsten/\-libfibre}}, + note = {[Online; accessed 2020-04-15]}, +} + @article{Linda, keywords = {Linda, concurrency}, @@ -4555,4 +4564,15 @@ address = {Belmont}, year = 1967, +} + +@inproceedings{Fang06, + author = {Fang, Yi and McMillan, Kenneth L. and Pnueli, Amir and Zuck, Lenore D.}, + editor = {Najm, Elie and Pradat-Peyre, Jean-Fran{\c{c}}ois and Donzeau-Gouge, V{\'e}ronique Vigui{\'e}}, + title = {Liveness by Invisible Invariants}, + booktitle = {Formal Techniques for Networked and Distributed Systems - FORTE 2006}, + year = 2006, + publisher = {Springer Berlin Heidelberg}, + address = {Berlin, Heidelberg}, + pages = {356--371}, } @@ -4739,5 +4759,5 @@ contributer = {pabuhr@plg}, author = {Gregory R. Andrews}, - title = {A Method for Solving Synronization Problems}, + title = {A Method for Solving Synchronization Problems}, journal = scp, volume = 13, @@ -5064,5 +5084,6 @@ title = {Multiple Inheritance for {C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}, booktitle = {Proceedings of the Spring '87 EUUG Conference}, - month = may, year = 1987 + month = may, + year = 1987, } @@ -6646,4 +6667,13 @@ } +@article{Aravind09, + author = {Alex A. Aravind and Wim H. Hesselink}, + title = {A Queue Based Mutual Exclusion Algorithm}, + journal = acta, + volume = 46, + pages = {73--86}, + year = 2009, +} + % R @@ -8030,4 +8060,20 @@ } +@article{Karsten20, + author = {Karsten, Martin and Barghi, Saman}, + title = {{User-level Threading: Have Your Cake and Eat It Too}}, + year = {2020}, + issue_date = {March 2020}, + publisher = {Association for Computing Machinery}, + address = {New York, NY, USA}, + volume = {4}, + number = {1}, + url = {https://doi.org/10.1145/3379483}, + doi = {10.1145/3379483}, + journal = {Proc. ACM Meas. Anal. Comput. Syst.}, + month = mar, + numpages = {30}, +} + @techreport{Harmony, keywords = {messages, concurrency}, @@ -8045,9 +8091,11 @@ contributer = {gjditchfield@plg}, author = {Henry Lieverman}, - title = {Using Prototypical Objects to Implement Shared Behavior in - Object Oriented Systems}, + title = {Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems}, journal = sigplan, - month = nov, year = 1986, - volume = 21, number = 11, pages = {214-223} + month = nov, + year = 1986, + volume = 21, + number = 11, + pages = {214-223} } Index: doc/theses/thierry_delisle_PhD/comp_II/Makefile =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/Makefile (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/Makefile (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -2,5 +2,5 @@ Build = build -Figures = figures +Figures = img Macros = ../../../LaTeXmacros TeXLIB = .:${Macros}:${Build}:../../../bibliography: Index: doc/theses/thierry_delisle_PhD/comp_II/comp_II.tex =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/comp_II.tex (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/comp_II.tex (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -3,17 +3,22 @@ \usepackage[T1]{fontenc} \usepackage[utf8]{inputenc} -\usepackage{listings} % for code listings \usepackage{xspace} \usepackage{xcolor} \usepackage{graphicx} \usepackage{epic,eepic} +\usepackage{listings} % for code listings \usepackage{glossaries} \usepackage{textcomp} +% cfa macros used in the document +\input{common} + +\setlist{topsep=6pt,parsep=0pt} % global reduce spacing between points +\newcommand{\uC}{$\mu$\CC} \usepackage[hidelinks]{hyperref} +\setlength{\abovecaptionskip}{5pt plus 3pt minus 2pt} +\lstMakeShortInline$% % single-character for \lstinline %\usepackage[margin=1in]{geometry} %\usepackage{float} -% cfa macros used in the document -\input{common} \input{glossary} @@ -27,6 +32,6 @@ \author{ - \huge Thierry Delisle \\ - \Large \vspace*{0.1in} \texttt{tdelisle@uwaterloo.ca} \\ + \huge Thierry Delisle \vspace*{5pt} \\ + \Large \texttt{tdelisle@uwaterloo.ca} \vspace*{5pt} \\ \Large Cheriton School of Computer Science \\ \Large University of Waterloo @@ -42,5 +47,5 @@ \newcommand{\cit}{\textsuperscript{[Citation Needed]}\xspace} -\newcommand{\TODO}{~\newline{\large\bf\color{red} TODO :}\xspace} +\newcommand{\TODO}{{\large\bf\color{red} TODO: }\xspace} % =============================================================================== @@ -54,18 +59,54 @@ \section{Introduction} \subsection{\CFA and the \CFA concurrency package} -\CFA\cit is a modern, polymorphic, non-object-oriented, backwards-compatible extension of the C programming language. It aims to add high-productivity features while maintaning the predictible performance of C. As such, concurrency in \CFA\cit aims to offer simple and safe high-level tools while still allowing performant code. \CFA concurrrent code is written in the synchronous programming paradigm but uses \glspl{uthrd} in order to achieve the simplicity and maintainability of synchronous programming without sacrificing the efficiency of asynchronous programing. As such, the \CFA \emph{scheduler} is a preemptive user-level scheduler that maps \glspl{uthrd} onto \glspl{kthrd}. - -Scheduling occurs when execution switches from one thread to another, where the second thread is implicitly chosen by the scheduler. This scheduling is an indirect handoff, as opposed to generators and coroutines which explicitly switch to the next generator and coroutine respectively. The cost of switching between two threads for an indirect handoff has two components : the cost of actually context-switching, i.e., changing the relevant registers to move execution from one thread to the other, and the cost of scheduling, i.e., deciding which thread to run next among all the threads ready to run. The first cost is generally constant and fixed\footnote{Affecting the context-switch cost is whether it is done in one step, after the scheduling, or in two steps, context-switching to a fixed third-thread before scheduling.}, while the scheduling cost can vary based on the system state. Adding multiple \glspl{kthrd} does not fundamentally change the scheduler semantics or requirements, it simply adds new correctness requirements, i.e. \textit{linearizability}, and a new dimension to performance: scalability, where scheduling cost now also depends on contention. - -The more threads switch, the more the administration cost of scheduling becomes noticeable. It is therefore important to build a scheduler with the lowest possible cost and latency. Another important consideration is \emph{fairness}. In principle, scheduling should give the illusion of perfect fairness, where all threads ready to run are running \emph{simultaneously}. While the illusion of simultaneity is easier to reason about, it can break down if the scheduler allows to much unfairness. Therefore, the scheduler should offer as much fairness as needed to guarantee eventual progress, but use unfairness to help performance. In practice, threads must wait in turn but there can be advantages to unfair scheduling, similar to the the express cash register at a grocery store. - -The goal of this research is to produce a scheduler that is simple for programmers to understand and offers good performance. Here understandability does not refer to the API but to how much scheduling concerns programmers need to take into account when writing a \CFA concurrent package. Therefore, the main goal of this proposal is : +\CFA\cite{Moss18} is a modern, polymorphic, non-object-oriented, concurrent, backwards-compatible extension of the C programming language. +It aims to add high-productivity features while maintaining the predictable performance of C. +As such, concurrency in \CFA\cite{Delisle19} aims to offer simple and safe high-level tools while still allowing performant code. +\CFA concurrent code is written in the synchronous programming paradigm but uses \glspl{uthrd} in order to achieve the simplicity and maintainability of synchronous programming without sacrificing the efficiency of asynchronous programing. +As such, the \CFA \newterm{scheduler} is a preemptive user-level scheduler that maps \glspl{uthrd} onto \glspl{kthrd}. + +\newterm{Scheduling} occurs when execution switches from one thread to another, where the second thread is implicitly chosen by the scheduler. +This scheduling is an indirect handoff, as opposed to generators and coroutines which explicitly switch to the next generator and coroutine respectively. +The cost of switching between two threads for an indirect handoff has two components: +\begin{enumerate} +\item +the cost of actually context-switching, \ie changing the relevant registers to move execution from one thread to the other, +\item +and the cost of scheduling, \ie deciding which thread to run next among all the threads ready to run. +\end{enumerate} +The first cost is generally constant and fixed\footnote{Affecting the constant context-switch cost is whether it is done in one step, after the scheduling, or in two steps, context-switching to a fixed third-thread before scheduling.}, while the scheduling cost can vary based on the system state. +Adding multiple \glspl{kthrd} does not fundamentally change the scheduler semantics or requirements, it simply adds new correctness requirements, \ie \newterm{linearizability}\footnote{Meaning however fast the CPU threads run, there is an equivalent sequential order that gives the same result.}, and a new dimension to performance: scalability, where scheduling cost now also depends on contention. + +The more threads switch, the more the administration cost of scheduling becomes noticeable. +It is therefore important to build a scheduler with the lowest possible cost and latency. +Another important consideration is \newterm{fairness}. +In principle, scheduling should give the illusion of perfect fairness, where all threads ready to run are running \emph{simultaneously}. +While the illusion of simultaneity is easier to reason about, it can break down if the scheduler allows too much unfairness. +Therefore, the scheduler should offer as much fairness as needed to guarantee eventual progress, but use unfairness to help performance. +In practice, threads must wait in turn but there can be advantages to unfair scheduling, similar to the the express cash-register at a grocery store. + +The goal of this research is to produce a scheduler that is simple for programmers to understand and offers good performance. +Here understandability does not refer to the API but to how much scheduling concerns programmers need to take into account when writing a \CFA concurrent package. +Therefore, the main goal of this proposal is : \begin{quote} The \CFA scheduler should be \emph{viable} for \emph{any} workload. \end{quote} -For a general purpose scheduler, it is impossible to produce an optimal algorithm as it would require knowledge of the future behaviour of threads. As such, scheduling performance is generally either defined by the best case scenario, i.e., a workload to which the scheduler is tailored, or the worst case scenario, i.e., the scheduler behaves no worst than \emph{X}. For this proposal, the performance is evaluated using the second approach to allow \CFA programmers to rely on scheduling performance. Be cause there is no optimal scheduler, ultimately \CFA may allow programmers to write their own scheduler; but that is not the subject of this proposal, which considers only the default scheduler. As such, it is important that only programmers with exceptionally high performance requirements should need to write their own scheduler and replace the scheduler in this proposal. - -Finally, the scheduling objective includes producing a scheduling strategy with sufficient fairness guarantees, creating an abstraction layer over the operating system to handle kernel-threads spinning unnecessarily, scheduling blocking I/O operations, and writing sufficient library tools to allow developers to indirectly use the scheduler. +For a general purpose scheduler, it is impossible to produce an optimal algorithm as it would require knowledge of the future behaviour of threads. +As such, scheduling performance is generally either defined by the best case scenario, \ie a workload to which the scheduler is tailored, or the worst case scenario, \ie the scheduler behaves no worst than \emph{X}. +For this proposal, the performance is evaluated using the second approach to allow \CFA programmers to rely on scheduling performance. +Because there is no optimal scheduler, ultimately \CFA may allow programmers to write their own scheduler; but that is not the subject of this proposal, which considers only the default scheduler. +As such, it is important that only programmers with exceptionally high performance requirements should need to write their own scheduler and replace the scheduler in this proposal. + +To achieve the \CFA scheduling goal includes: +\begin{enumerate} +\item +producing a scheduling strategy with sufficient fairness guarantees, +\item +creating an abstraction layer over the operating system to handle kernel-threads spinning unnecessarily, +\item +scheduling blocking I/O operations, +\item +and writing sufficient library tools to allow developers to indirectly use the scheduler, either through tuning knobs or replacing the default scheduler. +\end{enumerate} % =============================================================================== @@ -73,18 +114,37 @@ \section{\CFA Scheduling} -To scheduler user-level threads across all workloads, the scheduler has a number of requirements: - -\paragraph{Correctness} As with any other concurrent data structure or algorithm, the correctness requirement is paramount. The scheduler cannot allow threads to be dropped from the ready-queue, i.e., scheduled but never run, or be executed multiple times when only being scheduled once. Since \CFA concurrency has no spurious wakeup, this definition of correctness also means the scheduler should have no spurious wakeup. The \CFA scheduler must be correct. - -\paragraph{Performance} The performance of a scheduler can generally be mesured in terms of scheduling cost, scalability and latency. Scheduling cost is the cost to switch from one thread to another, as mentioned above. For simple applications where a single kernel thread does most of the scheduling, it is generally the dominating cost. When adding many kernel threads, scalability becomes an issue, effectively increasing the cost of context-switching when contention is high. Finally, a third axis of performance is tail latency. This measurement is related to fairness and mesures how long is needed for a thread to be run once scheduled and is evaluated in the worst cases. The \CFA scheduler should offer good performance in all three metrics. - -\paragraph{Fairness} Like performance, this requirements has several aspect : eventual progress, predictability and performance reliablility. As a hard requirement, the \CFA scheduler must guarantee eventual progress, i.e., prevent starvation, otherwise the above mentioned illusion of simultaneous execution is broken and the scheduler becomes much more complex to reason about. Beyond this requirement, performance should be predictible and reliable, which means similar workloads achieve similar performance and programmer intuition is respected. An example of this is : a thread that yields agressively should not run more often then other tasks. While this is intuitive, it does not hold true for many work-stealing or feedback based schedulers. The \CFA scheduler must guarantee eventual progress and should be predictible and offer reliable performance. - -\paragraph{Efficiency} Finally, efficient usage of CPU resources is also an important requirement. This issue is discussed more in depth towards the end of this proposal. It effectively refers to avoiding using CPU power when there are no threads to run, and conversely, use all CPUs available when the workload can benefit from it. Balancing these two states is where the complexity lies. The \CFA scheduler should be efficient with respect to the underlying (shared) computer. +To schedule user-level threads across all workloads, the scheduler has a number of requirements: + +\paragraph{Correctness} As with any other concurrent data structure or algorithm, the correctness requirement is paramount. +The scheduler cannot allow threads to be dropped from the ready queue, \ie scheduled but never run, or be executed multiple times when only being scheduled once. +Since \CFA concurrency has no spurious wakeup, this definition of correctness also means the scheduler should have no spurious wakeup. +The \CFA scheduler must be correct. + +\paragraph{Performance} The performance of a scheduler can generally be measured in terms of scheduling cost, scalability and latency. +\newterm{Scheduling cost} is the cost to switch from one thread to another, as mentioned above. +For simple applications, where a single kernel thread does most of the scheduling, it is generally the dominating cost. +\newterm{Scalability} is the cost of adding multiple kernel threads because it increases the time for context switching because of contention by multiple threads accessing shared resources, \eg the ready queue. +Finally, \newterm{tail latency} is service delay and relates to thread fairness. +Specifically, latency measures how long a thread waits to run once scheduled and is evaluated in the worst case. +The \CFA scheduler should offer good performance for all three metrics. + +\paragraph{Fairness} Like performance, this requirement has several aspect : eventual progress, predictability and performance reliability. +\newterm{Eventual progress} guarantees every scheduled thread is eventually run, \ie prevent starvation. +As a hard requirement, the \CFA scheduler must guarantee eventual progress, otherwise the above mentioned illusion of simultaneous execution is broken and the scheduler becomes much more complex to reason about. +\newterm{Predictability} and \newterm{reliability} means similar workloads achieve similar performance and programmer execution intuition is respected. +For example, a thread that yields aggressively should not run more often then other tasks. +While this is intuitive, it does not hold true for many work-stealing or feedback based schedulers. +The \CFA scheduler must guarantee eventual progress and should be predictable and offer reliable performance. + +\paragraph{Efficiency} Finally, efficient usage of CPU resources is also an important requirement and is discussed in depth towards the end of the proposal. +\newterm{Efficiency} means avoiding using CPU cycles when there are no threads to run, and conversely, use all CPUs available when the workload can benefit from it. +Balancing these two states is where the complexity lies. +The \CFA scheduler should be efficient with respect to the underlying (shared) computer. \bigskip To achieve these requirements, I can reject two broad types of scheduling strategies : feedback-based and priority schedulers. \subsection{Feedback-Based Schedulers} -Many operating systems use schedulers based on feedback in some form, e.g., measuring how much CPU a particular thread has used\footnote{Different metrics can measured here but it is not relevant to the discussion.} and schedule threads based on this metric. These strategies are sensible for operating systems but rely on two assumptions on the workload : +Many operating systems use schedulers based on feedback in some form, \eg measuring how much CPU a particular thread has used\footnote{Different metrics can be measured but it is not relevant to the discussion.} and schedule threads based on this metric. +These strategies are sensible for operating systems but rely on two assumptions for the workload: \begin{enumerate} @@ -93,39 +153,71 @@ \end{enumerate} -While these two assumptions generally hold for operating systems, they may not for user-level threading. Since \CFA has the explicit goal of allowing many smaller threads, this can naturally lead to threads with much shorter lifetime, which are only scheduled a few times. Scheduling strategies based on feedback cannot be effective in these cases because they do not have the opportunity to measure the metrics that underlie the algorithm. Note that the problem of feedback convergence (reacting too slowly to scheduling events) is not specific to short lived threads but can also occur with threads that show drastic changes in scheduling, e.g., threads running for long periods of time and then suddenly blocking and unblocking quickly and repeatedly. - -In the context of operating systems, these concerns can be overshadowed by a more pressing concern : security. When multiple users are involved, it is possible that some users are malevolent and try to exploit the scheduling strategy in order to achieve some nefarious objective. Security concerns mean that more precise and robust fairness metrics must be used to guarantee fairness across processes created by users as well as threads created within a process. In the case of the \CFA scheduler, every thread runs in the same user-space and is controlled by the same user. Fairness across users is therefore a given and it is then possible to safely ignore the possibility that threads are malevolent. This approach allows for a much simpler fairness metric and in this proposal ``fairness'' is considered as follows : when multiple threads are cycling through the system, the total ordering of threads being scheduled, i.e., pushed onto the ready-queue, should not differ much from the total ordering of threads being executed, i.e., popped from the ready-queue. - -Since feedback is not necessarily feasible within the lifetime of all threads and a simple fairness metric can be used, the scheduling strategy proposed for the \CFA runtime does not use per-threads feedback. Feedback in general is not rejected for secondary concerns like idle sleep for kernel threads, but no feedback is used to decide which thread to run next. +While these two assumptions generally hold for operating systems, they may not for user-level threading. +Since \CFA has the explicit goal of allowing many smaller threads, this can naturally lead to threads with much shorter lifetimes that are only scheduled a few times. +Scheduling strategies based on feedback cannot be effective in these cases because there is no opportunity to measure the metrics that underlie the algorithm. +Note, the problem of \newterm{feedback convergence} (reacting too slowly to scheduling events) is not specific to short lived threads but can also occur with threads that show drastic changes in scheduling, \eg threads running for long periods of time and then suddenly blocking and unblocking quickly and repeatedly. + +In the context of operating systems, these concerns can be overshadowed by a more pressing concern : security. +When multiple users are involved, it is possible some users are malevolent and try to exploit the scheduling strategy to achieve some nefarious objective. +Security concerns mean more precise and robust fairness metrics must be used to guarantee fairness across processes created by users as well as threads created within a process. +In the case of the \CFA scheduler, every thread runs in the same user space and is controlled by the same user. +Fairness across users is therefore a given and it is then possible to safely ignore the possibility that threads are malevolent. +This approach allows for a much simpler fairness metric and in this proposal \emph{fairness} is defined as: when multiple threads are cycling through the system, the total ordering of threads being scheduled, \ie pushed onto the ready-queue, should not differ much from the total ordering of threads being executed, \ie popped from the ready-queue. + +Since feedback is not necessarily feasible within the lifetime of all threads and a simple fairness metric can be used, the scheduling strategy proposed for the \CFA runtime does not use per-threads feedback. +Feedback in general is not rejected for secondary concerns like idle sleep for kernel threads, but no feedback is used to decide which thread to run next. \subsection{Priority Schedulers} -Another broad category of schedulers are priority schedulers. In these scheduling strategies, threads have priorities and the runtime schedules the threads with the highest priority before scheduling other threads. Threads with equal priority are scheduled using a secondary strategy, often something simple like round-robin or FIFO. These priority mean that, as long as there is a thread with a higher priority that desires to run, a thread with a lower priority does not run. This possible starving of threads can dramatically increase programming complexity since starving threads and priority inversion (prioritizing a lower priority thread) can both lead to serious problems. - -An important observation to make is that threads do not need to have explicit priorities for problems to occur. Indeed, any system with multiple ready-queues and attempts to exhaust one queue before accessing the other queues, can encounter starvation problems. A popular scheduling strategy that suffers from implicit priorities is work-stealing. Work-stealing is generally presented as follows, each processor has a list of ready threads. -\begin{enumerate} - \item Run threads from ``this'' processor's list first. - \item If ``this'' processor's list is empty, run threads from some other processor's list. -\end{enumerate} - -In a loaded system\footnote{A loaded system is a system where threads are being run at the same rate they are scheduled.}, if a thread does not yield, block or preempt for an extended period of time, threads on the same processor's list starve if no other processors exhaust their list. - -Since priorities can be complex for programmers to handle, the scheduling strategy proposed for the \CFA runtime does not use a strategy with either implicit or explicit thread priorities. +Another broad category of schedulers are priority schedulers. +In these scheduling strategies, threads have priorities and the runtime schedules the threads with the highest priority before scheduling other threads. +Threads with equal priority are scheduled using a secondary strategy, often something simple like round-robin or FIFO. +A consequence of priority is that, as long as there is a thread with a higher priority that desires to run, a thread with a lower priority does not run. +This possible starving of threads can dramatically increase programming complexity since starving threads and priority inversion (prioritizing a lower priority thread) can both lead to serious problems. + +An important observation is that threads do not need to have explicit priorities for problems to occur. +Indeed, any system with multiple ready-queues that attempts to exhaust one queue before accessing the other queues, essentially provide implicit priority, which can encounter starvation problems. +For example, a popular scheduling strategy that suffers from implicit priorities is work stealing. +\newterm{Work stealing} is generally presented as follows: +\begin{enumerate} + \item Each processor has a list of ready threads. + \item Each processor runs threads from its ready queue first. + \item If a processor's ready queue is empty, attempt to run threads from some other processor's ready queue. +\end{enumerate} + +In a loaded system\footnote{A \newterm{loaded system} is a system where threads are being run at the same rate they are scheduled.}, if a thread does not yield, block, or preempt for an extended period of time, threads on the same processor's list starve if no other processors exhaust their list. + +Since priorities can be complex for programmers to incorporate into their execution intuition, the scheduling strategy proposed for the \CFA runtime does not use a strategy with either implicit or explicit thread priorities. \subsection{Schedulers without feedback or priorities} -This proposal conjectures that is is possible to construct a default scheduler for the \CFA runtime that offers good scalability and a simple fairness guarantee that is easy for programmers to reason about. The simplest fairness guarantee is FIFO ordering, i.e., threads scheduled first run first. However, enforcing FIFO ordering generally conflicts with scalability across multiple processors because of the additionnal synchronization. Thankfully, strict FIFO is not needed for sufficient fairness. Since concurrency is inherently non-deterministic, fairness concerns in scheduling are only a problem if a thread repeatedly runs before another thread can run. This relaxation is possible because the non-determinism means that programmers must already handle ordering problems in order to produce correct code and already must rely on weak guarantees, for example that a specific thread will \emph{eventually} run. Since some reordering does not break correctness, the FIFO fairness guarantee can be significantly relaxed without causing problems. For this proposal, the target guarantee is that the \CFA scheduler provides \emph{probable} FIFO ordering, which allows reordering but makes it improbable that threads are reordered far from their position in total ordering. - -Scheduling is defined as follows : +This proposal conjectures that is is possible to construct a default scheduler for the \CFA runtime that offers good scalability and a simple fairness guarantee that is easy for programmers to reason about. +The simplest fairness guarantee is FIFO ordering, \ie threads scheduled first run first. +However, enforcing FIFO ordering generally conflicts with scalability across multiple processors because of the additional synchronization. +Thankfully, strict FIFO is not needed for sufficient fairness. +Since concurrency is inherently non-deterministic, fairness concerns in scheduling are only a problem if a thread repeatedly runs before another thread can run. +Some relaxation is possible because non-determinism means programmers already handle ordering problems to produce correct code and hence rely on weak guarantees, \eg that a specific thread will \emph{eventually} run. +Since some reordering does not break correctness, the FIFO fairness guarantee can be significantly relaxed without causing problems. +For this proposal, the target guarantee is that the \CFA scheduler provides \emph{probable} FIFO ordering, which allows reordering but makes it improbable that threads are reordered far from their position in total ordering. + +The \CFA scheduler fairness is defined as follows: \begin{itemize} \item Given two threads $X$ and $Y$, the odds that thread $X$ runs $N$ times \emph{after} thread $Y$ is scheduled but \emph{before} it is run, decreases exponentially with regard to $N$. \end{itemize} - While this is not a bounded guarantee, the probability that unfairness persist for long periods of times decreases exponentially, making persisting unfairness virtually impossible. % =============================================================================== % =============================================================================== -\section{Proposal} - -\subsection{Ready-Queue} \label{sec:queue} -A simple ready-queue can be built from a FIFO queue, where user-threads are pushed onto the queue when they are ready to run, and processors (kernel-threads acting as virtual processors) pop the user-threads from the queue and execute them. Using the paper\cite{alistarh2018relaxed} as a basis, it is simple to build a relaxed FIFO list that is fast and scalable for loaded or overloaded systems. The described queue uses an array of underlying strictly FIFO queues as shown in Figure~\ref{fig:base}\footnote{For this section, the number of underlying queues is assumed to be constant. Section~\ref{sec:resize} discusses resizing the array.}. Pushing new data is done by selecting one of these underlying queues at random, recording a timestamp for the operation and pushing to the selected queue. Popping is done by selecting two queues at random and popping from the queue with the oldest timestamp. A higher number of underlying queues leads to less contention on each queue and therefore better performance. In a loaded system, it is highly likely the queues are non-empty, i.e., several tasks are on each of the underlying queues. This means that selecting a queue at random to pop from is highly likely to yield a queue with available items. In Figure~\ref{fig:base}, ignoring the ellipsis, the chances of getting an empty queue is 2/7 per pick, meaning two random picks yield an item approximately 9 times out of 10. +\section{Proposal Details} + +\subsection{Central Ready Queue} \label{sec:queue} +A central ready queue can be built from a FIFO queue, where user threads are pushed onto the queue when they are ready to run, and processors (kernel-threads acting as virtual processors) pop the user threads from the queue and execute them. +Alistarh \etal~\cite{alistarh2018relaxed} show it is straightforward to build a relaxed FIFO list that is fast and scalable for loaded or overloaded systems. +The described queue uses an array of underlying strictly FIFO queues as shown in Figure~\ref{fig:base}\footnote{For this section, the number of underlying queues is assumed to be constant. +Section~\ref{sec:resize} discusses resizing the array.}. +Pushing new data is done by selecting one of these underlying queues at random, recording a timestamp for the operation and pushing to the selected queue. +Popping is done by selecting two queues at random and popping from the queue with the oldest timestamp. +A higher number of underlying queues leads to less contention on each queue and therefore better performance. +In a loaded system, it is highly likely the queues are non-empty, \ie several tasks are on each of the underlying queues. +This means that selecting a queue at random to pop from is highly likely to yield a queue with available items. +In Figure~\ref{fig:base}, ignoring the ellipsis, the chances of getting an empty queue is 2/7 per pick, meaning two random picks yield an item approximately 9 times out of 10. \begin{figure} @@ -133,5 +225,6 @@ \input{base} \end{center} - \caption{Relaxed FIFO list at the base of the scheduler: an array of strictly FIFO lists. The timestamp is in all nodes and cell arrays.} + \caption{Relaxed FIFO list at the base of the scheduler: an array of strictly FIFO lists. +The timestamp is in all nodes and cell arrays.} \label{fig:base} \end{figure} @@ -145,5 +238,15 @@ \end{figure} -When the ready queue is \emph{more empty}, i.e., several of the queues are empty, selecting a random queue for popping is less likely to yield a valid selection and more attempts need to be made, resulting in a performance degradation. Figure~\ref{fig:empty} shows an example with fewer elements where the chances of getting an empty queue is 5/7 per pick, meaning two random picks yield an item only half the time. Since the ready queue is not empty, the pop operation \emph{must} find an element before returning and therefore must retry. Overall performance is therefore influenced by the contention on the underlying queues and pop performance is influenced by the item density. This leads to four performance cases, as depicted in Table~\ref{tab:perfcases}. +When the ready queue is \emph{more empty}, \ie several of the queues are empty, selecting a random queue for popping is less likely to yield a successful selection and more attempts are needed, resulting in a performance degradation. +Figure~\ref{fig:empty} shows an example with fewer elements, where the chances of getting an empty queue is 5/7 per pick, meaning two random picks yield an item only half the time. +Since the ready queue is not empty, the pop operation \emph{must} find an element before returning and therefore must retry. +Note, the popping kernel thread has no work to do, but CPU cycles are wasted both for available user and kernel threads during the pop operation as the popping thread is using a CPU. +Overall performance is therefore influenced by the contention on the underlying queues and pop performance is influenced by the item density. + +This leads to four performance cases for the centralized ready-queue, as depicted in Table~\ref{tab:perfcases}. +The number of processors (many or few) refers to the number of kernel threads \emph{actively} attempting to pop user threads from the queues, not the total number of kernel threads. +The number of threads (many or few) refers to the number of user threads ready to be run. +Many threads means they outnumber processors significantly and most underlying queues have items, few threads mean there are barely more threads than processors and most underlying queues are empty. +Cases with fewer threads than processors are discussed in Section~\ref{sec:sleep}. \begin{table} @@ -155,25 +258,26 @@ Many Threads & A: good performance & B: good performance \\ \hline - Few Threads & C: poor performance & D: poor performance \\ + Few Threads & C: worst performance & D: poor performance \\ \hline \end{tabular} \end{center} - \caption{Performance of the relaxed FIFO list in different cases. The number of processors (many or few) refers to the number of kernel-threads \emph{actively} attempting to pop user-threads from the queues, not the total number of kernel-threads. The number of threads (many or few) refers to the number of user-threads ready to be run. Many threads means they outnumber processors significantly and most underlying queues have items, few threads mean there are barely more threads than processors and most underlying queues are empty. Cases with fewer threads than processors are discussed in Section~\ref{sec:sleep}.} + \caption{Expected performance of the relaxed FIFO list in different cases.} \label{tab:perfcases} \end{table} -Table~\ref{tab:perfcases} - -Performance can be improved in case~D (Table~\ref{tab:perfcases}) by adding information to help processors find which inner queues are used. This addition aims to avoid the cost of retrying the pop operation but does not affect contention on the underlying queues and can incur some management cost for both push and pop operations. The approach used to encode this information can vary in density and be either global or local, where density means the information is either packed in few cachelines or spread across several cachelines, and local information means each thread uses an independent copy instead of a single global, i.e., common, source of information. - -For example, bitmask can be used to identify which inner queues are currently in use, as shown in Figure~\ref{fig:emptybit}. This means that processors can often find user-threads in constant time, regardless of how many underlying queues are empty. Furthermore, modern x86 CPUs have extended bit manipulation instructions (BMI2) which allow using the bitmask with very little overhead compared to the randomized selection approach for a filled readyqueue, offerring decent performance even in cases with many empty inner queues. However, this technique has its limits: with a single word\footnote{Word refers here to however many bits can be written atomicly.} bitmask, the total number of underlying queues in the ready queue is limited to the number of bits in the word. With a multi-word bitmask, this maximum limit can be increased arbitrarily, but it is not possible to check if the queue is empty by reading the bitmask atomicly. - -Finally, a dense bitmap, either single or multi-word, causes additional problems -in case C (Table 1), because many processors are continuously scanning the -bitmask to find the few available threads. This increased contention on the -bitmask(s) reduces performance because of cache misses and the bitmask is -updated more frequently by the scanning processors racing to read and/or update -that information. This increased update frequency means the information in the -bitmask will more often be stale before a processor can use it to find an item. +Performance can be improved in case~D (Table~\ref{tab:perfcases}) by adding information to help processors find which inner queues are used. +This addition aims to avoid the cost of retrying the pop operation but does not affect contention on the underlying queues and can incur some management cost for both push and pop operations. +The approach used to encode this information can vary in density and be either global or local. +\newterm{Density} means the information is either packed in a few cachelines or spread across several cachelines, and \newterm{local information} means each thread uses an independent copy instead of a single global, \ie common, source of information. + +For example, Figure~\ref{fig:emptybit} shows a dense bitmask to identify which inner queues are currently in use. +This approach means processors can often find user threads in constant time, regardless of how many underlying queues are empty. +Furthermore, modern x86 CPUs have extended bit manipulation instructions (BMI2) that allow using the bitmask with very little overhead compared to the randomized selection approach for a filled ready queue, offering good performance even in cases with many empty inner queues. +However, this technique has its limits: with a single word\footnote{Word refers here to however many bits can be written atomically.} bitmask, the total number of underlying queues in the ready queue is limited to the number of bits in the word. +With a multi-word bitmask, this maximum limit can be increased arbitrarily, but it is not possible to check if the queue is empty by reading the bitmask atomically. + +Finally, a dense bitmap, either single or multi-word, causes additional problems in case C (Table 1), because many processors are continuously scanning the bitmask to find the few available threads. +This increased contention on the bitmask(s) reduces performance because of cache misses after updates and the bitmask is updated more frequently by the scanning processors racing to read and/or update that information. +This increased update frequency means the information in the bitmask is more often stale before a processor can use it to find an item, \ie mask read says there are available user threads but none on queue. \begin{figure} @@ -185,5 +289,7 @@ \end{figure} -Another approach is to use a hiearchical data structure, for example Figure~\ref{fig:emptytree}. Creating a tree of nodes to reduce contention has been shown to work in similar cases\cite{ellen2007snzi}\footnote{This particular paper seems to be patented in the US. How does that affect \CFA? Can I use it in my work?}. However, this approach may lead to poorer performance in case~B (Table~\ref{tab:perfcases}) due to the inherent pointer chasing cost and already low contention cost in that case. +Figure~\ref{fig:emptytree} shows another approach using a hierarchical tree data-structure to reduce contention and has been shown to work in similar cases~\cite{ellen2007snzi}\footnote{This particular paper seems to be patented in the US. +How does that affect \CFA? Can I use it in my work?}. +However, this approach may lead to poorer performance in case~B (Table~\ref{tab:perfcases}) due to the inherent pointer chasing cost and already low contention cost in that case. \begin{figure} @@ -195,9 +301,14 @@ \end{figure} -Finally, a third approach is to use dense information, similar to the bitmap, but have each thread keep its own independant copies of it. While this approach can offer good scalability \emph{and} low latency, the livelyness of the information can become a problem. In the simple cases, local copies of which underlying queues are empty can become stale and end-up not being useful for the pop operation. A more serious problem is that reliable information is necessary for some parts of this algorithm to be correct. As mentionned in this section, processors must know \emph{reliably} whether the list is empty or not to decide if they can return \texttt{NULL} or if they must keep looking during a pop operation. Section~\ref{sec:sleep} discusses another case where reliable information is required for the algorithm to be correct. - -\begin{figure} - \begin{center} - {\resizebox{0.8\textwidth}{!}{\input{emptytls}}} +Finally, a third approach is to use dense information, similar to the bitmap, but have each thread keep its own independent copy of it. +While this approach can offer good scalability \emph{and} low latency, the liveliness of the information can become a problem. +In the simple cases, local copies of which underlying queues are empty can become stale and end-up not being useful for the pop operation. +A more serious problem is that reliable information is necessary for some parts of this algorithm to be correct. +As mentioned in this section, processors must know \emph{reliably} whether the list is empty or not to decide if they can return \texttt{NULL} or if they must keep looking during a pop operation. +Section~\ref{sec:sleep} discusses another case where reliable information is required for the algorithm to be correct. + +\begin{figure} + \begin{center} + \input{emptytls} \end{center} \caption{``More empty'' queue with added per processor bitmask to indicate which array cells have items.} @@ -205,15 +316,26 @@ \end{figure} -There is a fundamental tradeoff among these approach. Dense global information about empty underlying queues helps zero-contention cases at the cost of high-contention case. Sparse global information helps high-contention cases but increases latency in zero-contention-cases, to read and ``aggregate'' the information\footnote{Hiearchical structures, e.g., binary search tree, effectively aggregate information but following pointer chains, learning information for each node. Similarly, other sparse schemes would need to read multiple cachelines to acquire all the information needed.}. Finally, dense local information has both the advantages of low latency in zero-contention cases and scalability in high-contention cases, however the information can become stale making it difficult to use to ensure correctness. The fact that these solutions have these fundamental limits suggest to me that a better solution combines these properties in an interesting ways. The lock discussed in Section~\ref{sec:resize} also allows for solutions that adapt to the number of processors, which could also prove useful. +There is a fundamental tradeoff among these approach. +Dense global information about empty underlying queues helps zero-contention cases at the cost of high-contention case. +Sparse global information helps high-contention cases but increases latency in zero-contention-cases, to read and ``aggregate'' the information\footnote{Hierarchical structures, \eg binary search tree, effectively aggregate information but follow pointer chains, learning information at each node. +Similarly, other sparse schemes need to read multiple cachelines to acquire all the information needed.}. +Finally, dense local information has both the advantages of low latency in zero-contention cases and scalability in high-contention cases, however the information can become stale making it difficult to use to ensure correctness. +The fact that these solutions have these fundamental limits suggest to me a better solution that attempts to combine these properties in an interesting ways. +Also, the lock discussed in Section~\ref{sec:resize} allows for solutions that adapt to the number of processors, which could also prove useful. \paragraph{Objectives and Existing Work} -How much scalability is actually needed is highly debatable \emph{libfibre}\cit has compared favorably to other schedulers in webserver tests\cit and uses a single atomic counter in its scheduling algorithm similarly to the proposed bitmask. As such, the single atomic instruction on a shared cacheline may be sufficiently performant. - -I have built a prototype of this ready-queue in the shape of a data-queue, i.e., nodes on the queue are structures with a single int and the intrusive data fields. Using this prototype I ran preliminary performance experiments which confirm the expected performance in Table~\ref{tab:perfcases}. However, these experiments only offer a hint at the actual performance of the scheduler since threads form more complex operations than simple integer nodes, e.g., threads are not independant of each other, when a thread blocks some other thread must intervene to wake it. - -I have also integrated this prototype into the \CFA runtime, but have not yet created performance experiments to compare results. As creating one-to-one comparisons with the prototype will be complex. +How much scalability is actually needed is highly debatable. +\emph{libfibre}\cite{libfibre} has compared favorably to other schedulers in webserver tests\cite{karstenuser} and uses a single atomic counter in its scheduling algorithm similarly to the proposed bitmask. +As such, the single atomic instruction on a shared cacheline may be sufficiently performant. + +I have built a prototype of this ready queue in the shape of a data queue, \ie nodes on the queue are structures with a single int representing a thread and intrusive data fields. +Using this prototype I ran preliminary performance experiments that confirm the expected performance in Table~\ref{tab:perfcases}. +However, these experiments only offer a hint at the actual performance of the scheduler since threads form more complex operations than simple integer nodes, \eg threads are not independent of each other, when a thread blocks some other thread must intervene to wake it. + +I have also integrated this prototype into the \CFA runtime, but have not yet created performance experiments to compare results, as creating one-to-one comparisons between the prototype and the \CFA runtime will be complex. \subsection{Dynamic Resizing} \label{sec:resize} + \begin{figure} \begin{center} @@ -224,5 +346,15 @@ \end{figure} -The \CFA runtime system groups processors together as clusters. Threads on a cluster are always scheduled on one of the processors of the cluster. Currently, the runtime handles dynamically adding and removing processors from clusters at any time. Since this is part of the existing design, the proposed scheduler must also support this behaviour. However, dynamicaly resizing a cluster is considered a rare event associated with setup, teardown and major configuration changes. This assumption is made both in the design of the proposed scheduler as well as in the original design of the \CFA runtime system. As such, the proposed scheduler must honor the correctness of these behaviour but does not have any performance objectives with regard to resizing a cluster. How long adding or removing processors take and how much this disrupts the performance of other threads is considered a secondary concern since it should be amortized over long period of times. However, as mentionned in Section~\ref{sec:queue}, contention on the underlying queues can have a direct impact on performance. The number of underlying queues must therefore be adjusted as the number of processors grows or shrinks. Since the underlying queues are stored in a dense array, changing the number of queues requires resizing the array and expanding the array requires moving it. This can introduce memory reclamation problems if not done correctly. +The \CFA runtime system groups processors together as \newterm{clusters}, as shown in Figure~\ref{fig:system}. +Threads on a cluster are always scheduled on one of the processors of the cluster. +Currently, the runtime handles dynamically adding and removing processors from clusters at any time. +Since this is part of the existing design, the proposed scheduler must also support this behaviour. +However, dynamically resizing a cluster is considered a rare event associated with setup, tear down and major configuration changes. +This assumption is made both in the design of the proposed scheduler as well as in the original design of the \CFA runtime system. +As such, the proposed scheduler must honour the correctness of this behaviour but does not have any performance objectives with regard to resizing a cluster. +How long adding or removing processors take and how much this disrupts the performance of other threads is considered a secondary concern since it should be amortized over long period of times. +However, as mentioned in Section~\ref{sec:queue}, contention on the underlying queues can have a direct impact on performance. +The number of underlying queues must therefore be adjusted as the number of processors grows or shrinks. +Since the underlying queues are stored in a dense array, changing the number of queues requires resizing the array and expanding the array requires moving it, which can introduce memory reclamation problems if not done correctly. \begin{figure} @@ -230,37 +362,125 @@ \input{resize} \end{center} - \caption{Copy of data structure shown in Figure~\ref{fig:base}. } + \caption{Copy of data structure shown in Figure~\ref{fig:base}.} \label{fig:base2} \end{figure} -It is important to note how the array is used in this case. While the array cells are modified by every push and pop operation, the array itself, i.e., the pointer that would change when resized, is only read during these operations. Therefore the use of this pointer can be described as frequent reads and infrequent writes. This description effectively matches with the description of a Reader-Writer lock, infrequent but invasive updates among frequent read operations. In the case of the Ready-Queue described above, read operations are operations that push or pop from the ready-queue but do not invalidate any references to the ready queue data structures. Writes on the other-hand would add or remove inner queues, invalidating references to the array of inner queues in the process. Therefore, the current proposed approach to this problem is to add a per-cluster Reader Writer lock around the ready queue to prevent restructuring of the ready-queue data structure while threads are being pushed or popped. - -There are possible alternatives to the Reader Writer lock solution. This problem is effectively a memory reclamation problem and as such there is a large body of research on the subject\cit. However, the RWlock solution is simple and can be leveraged to solve other problems (e.g., processor ordering and memory reclamation of threads), which makes it an attractive solution. +It is important to note how the array is used in this case. +While the array cells are modified by every push and pop operation, the array itself, \ie the pointer that would change when resized, is only read during these operations. +Therefore the use of this pointer can be described as frequent reads and infrequent writes. +This description effectively matches with the description of a reader-writer lock, infrequent but invasive updates among frequent read operations. +In the case of the ready queue described above, read operations are operations that push or pop from the ready queue but do not invalidate any references to the ready queue data structures. +Writes on the other hand would add or remove inner queues, invalidating references to the array of inner queues in a process. +Therefore, the current proposed approach to this problem is to add a per-cluster reader-writer lock around the ready queue to prevent restructuring of the ready-queue data-structure while threads are being pushed or popped. + +There are possible alternatives to the reader-writer lock solution. +This problem is effectively a memory reclamation problem and as such there is a large body of research on the subject\cite{michael2004hazard, brown2015reclaiming}. +However, the reader-write lock-solution is simple and can be leveraged to solve other problems (\eg processor ordering and memory reclamation of threads), which makes it an attractive solution. \paragraph{Objectives and Existing Work} -The lock must offer scalability and performance on par with the actual ready-queue in order not to introduce a new bottleneck. I have already built a lock that fits the desired requirements and preliminary testing show scalability and performance that exceed the target. As such, I do not consider this lock to be a risk on this project. +The lock must offer scalability and performance on par with the actual ready-queue in order not to introduce a new bottleneck. +I have already built a lock that fits the desired requirements and preliminary testing show scalability and performance that exceed the target. +As such, I do not consider this lock to be a risk for this project. \subsection{Idle Sleep} \label{sec:sleep} -As mentioned, idle sleep is the process of putting processors to sleep when they have no threads to execute. In this context, processors are kernel-threads and sleeping refers to asking the kernel to block a thread. This benefit can be achieved with either thread synchronization operations like pthread\_cond\_wait or using signal operations like sigsuspend. The goal of putting idle processors to sleep is two-fold, it reduces energy consumption in cases where more idle kernel-threads translate to idle hardware threads, and reduces contention on the ready queue, since the otherwise idle processors generally contend trying to pop items from the queue. - -Support for idle sleep broadly involves calling the operating system to block the kernel thread and handling the race between a blocking thread and the waking thread, and handling which kernel thread should sleep or wake-up. - -When a processor decides to sleep, there is a race that occurs between it signalling that is going to sleep (so other processors can find sleeping processors) and actually blocking the kernel thread. This is equivalent to the classic problem of missing signals when using condition variables: the ``sleepy'' processor indicates that it will sleep but has not yet gone to sleep, when another processor attempts to wake it up, the waking-up operation may claim nothing needs to be done and the signal is missed. In cases where threads are scheduled from processors on the current cluster, loosing signals is not necessarily critical, because at least some processors on the cluster are awake and may check for more processors eventually. Individual processors always finish scheduling threads before looking for new work, which means that the last processor to go to sleep cannot miss threads scheduled from inside the cluster (if they do, that demonstrates the ready-queue is not linearizable). However, this guarantee does not hold if threads are scheduled from outside the cluster, either due to an external event like timers and I/O, or due to a thread migrating from a different cluster. In this case, missed signals can lead to the cluster deadlocking where it should not\footnote{Clusters ``should'' never deadlock, but for this proposal, cases where \CFA users \emph{actually} write \CFA code that leads to a deadlock is considered as a deadlock that ``should'' happen. }. Therefore, it is important that the scheduling of threads include a mechanism where signals \emph{cannot} be missed. For performance reasons, it can be advantageous to have a secondary mechanism that allows signals to be missed in cases where it cannot lead to a deadlock. To be safe, this process must include a ``handshake'' where it is guaranteed that either~: the sleepy processor notices that a thread is scheduled after it signalled its intent to block or code scheduling threads sees the intent to sleep before scheduling and be able to wake-up the processor. This matter is complicated by the fact that pthreads offers few tools to implement this solution and offers no guarantee of ordering of threads waking up for most of these tools. - -Another issues is trying to avoid kernel threads sleeping and waking frequently. A possible partial solution is to order the processors so that the one which most recently went to sleep is woken up. This allows other sleeping processors to reach deeper sleep state (when these are available) while keeping ``hot'' processors warmer. Note that while this generally means organising the processors in a stack, I believe that the unique index provided by the ReaderWriter lock can be reused to strictly order the waking order of processors, causing a LIFO like waking order. While a strict LIFO stack is probably better, using the processor index could prove useful and offer a sufficiently LIFO ordering. - -Finally, another important aspect of Idle Sleep is when should processors make the decision to sleep and when is it appropriate for sleeping processors to be woken up. Processors that are unnecessarily unblocked lead to unnecessary contention and power consumption, while too many sleeping processors can lead to sub-optimal throughput. Furthermore, transitions from sleeping to awake and vice-versa also add unnecessary latency. There is already a wealth of research on the subject and I may use an existing approach for the Idle Sleep heuristic in this project. + +\newterm{Idle sleep} is the process of putting processors to sleep when they have no threads to execute. +In this context, processors are kernel threads and sleeping refers to asking the kernel to block a thread. +This operation can be achieved with either thread synchronization operations like $pthread_cond_wait$ or using signal operations like $sigsuspend$. +The goal of putting idle processors to sleep is: +\begin{enumerate} +\item +reduce contention on the ready queue, since the otherwise idle processors generally contend trying to pop items from the queue, +\item +give back unneeded CPU time associated with a process to other user processors executing on the computer, +\item +and reduce energy consumption in cases where more idle kernel-threads translate to idle CPUs, which can cycle down. +\end{enumerate} +Support for idle sleep broadly involves calling the operating system to block the kernel thread and handling the race between a blocking thread and the waking thread, and handling which kernel thread should sleep or wake up. + +When a processor decides to sleep, there is a race that occurs between it signalling that is going to sleep (so other processors can find sleeping processors) and actually blocking the kernel thread. +This operation is equivalent to the classic problem of missing signals when using condition variables: the ``sleepy'' processor indicates its intention to block but has not yet gone to sleep when another processor attempts to wake it up. +The waking-up operation sees the blocked process and signals it, but the blocking process is racing to sleep so the signal is missed. +In cases where kernel threads are managed as processors on the current cluster, loosing signals is not necessarily critical, because at least some processors on the cluster are awake and may check for more processors eventually. +Individual processors always finish scheduling user threads before looking for new work, which means that the last processor to go to sleep cannot miss threads scheduled from inside the cluster (if they do, that demonstrates the ready queue is not linearizable). +However, this guarantee does not hold if threads are scheduled from outside the cluster, either due to an external event like timers and I/O, or due to a user (or kernel) thread migrating from a different cluster. +In this case, missed signals can lead to the cluster deadlocking\footnote{Clusters should only deadlock in cases where a \CFA programmer \emph{actually} write \CFA code that leads to a deadlock.}. +Therefore, it is important that the scheduling of threads include a mechanism where signals \emph{cannot} be missed. +For performance reasons, it can be advantageous to have a secondary mechanism that allows signals to be missed in cases where it cannot lead to a deadlock. +To be safe, this process must include a ``handshake'' where it is guaranteed that either~: the sleeping processor notices that a user thread is scheduled after the sleeping processor signalled its intent to block or code scheduling threads sees the intent to sleep before scheduling and be able to wake-up the processor. +This matter is complicated by the fact that pthreads and Linux offer few tools to implement this solution and no guarantee of ordering of threads waking up for most of these tools. + +Another important issue is avoiding kernel threads sleeping and waking frequently because there is a significant operating-system cost. +This scenario happens when a program oscillates between high and low activity, needing most and then less processors. +A possible partial solution is to order the processors so that the one which most recently went to sleep is woken up. +This allows other sleeping processors to reach deeper sleep state (when these are available) while keeping ``hot'' processors warmer. +Note that while this generally means organizing the processors in a stack, I believe that the unique index provided in my reader-writer lock can be reused to strictly order the waking processors, causing a mostly LIFO order. +While a strict LIFO stack is probably better, the processor index could prove useful for other reasons, while still offering a sufficiently LIFO ordering. + +A final important aspect of idle sleep is when should processors make the decision to sleep and when is it appropriate for sleeping processors to be woken up. +Processors that are unnecessarily unblocked lead to unnecessary contention, CPU usage, and power consumption, while too many sleeping processors can lead to sub-optimal throughput. +Furthermore, transitions from sleeping to awake and vice-versa also add unnecessary latency. +There is already a wealth of research on the subject\cite{schillings1996engineering, wiki:thunderherd} and I may use an existing approach for the idle-sleep heuristic in this project, \eg\cite{karstenuser}. \subsection{Asynchronous I/O} -The final aspect of this proposal is asynchronous I/O. Without it, user threads that execute I/O operations block the underlying kernel thread, which leads to poor throughput. It would be preferrable to block the user-thread and reuse the underlying kernel-thread to run other ready threads. This approach requires intercepting the user-threads' calls to I/O operations, redirecting them to an asynchronous I/O interface and handling the multiplexing between the synchronous and asynchronous API. As such, these are the three components needed to implemented support for asynchronous I/O : an OS abstraction layer over the asynchronous interface, an event-engine to (de)multiplex the operations and a synchronous interface for users to use. None of these components currently exist in \CFA and I will need to build all three for this project. + +The final aspect of this proposal is asynchronous I/O. +Without it, user threads that execute I/O operations block the underlying kernel thread, which leads to poor throughput. +It is preferable to block the user thread performing the I/O and reuse the underlying kernel-thread to run other ready user threads. +This approach requires intercepting user-thread calls to I/O operations, redirecting them to an asynchronous I/O interface, and handling the multiplexing/demultiplexing between the synchronous and asynchronous API. +As such, there are three components needed to implemented support for asynchronous I/O: +\begin{enumerate} +\item +an OS abstraction layer over the asynchronous interface, +\item +an event-engine to (de)multiplex the operations, +\item +and a synchronous interface for users to use. +\end{enumerate} +None of these components currently exist in \CFA and I will need to build all three for this project. \paragraph{OS Abstraction} -One fundamental part for converting blocking I/O operations into non-blocking ones is having an underlying asynchronous I/O interface to direct the I/O operations. While there exists many different APIs for asynchronous I/O, it is not part of this proposal to create a novel API. I plan to use an existing one that is sufficient. uC++ uses the \texttt{select} as its interface, which handles ttys, pipes and sockets, but not disk. It entails significant complexity and is being replaced, which make it a less interesting alternative. Another popular interface is \texttt{epoll}\cit, which is supposed to be cheaper than \texttt{select}. However, epoll also does not handle the file system and seems to have problem to linux pipes and \texttt{TTY}s\cit. A very recent alternative that must still be investigated is \texttt{io\_uring}. It claims to address some of the issues with \texttt{epoll} but is too recent to be confident that it does. Finally, a popular cross-platform alternative is \texttt{libuv}, which offers asynchronous sockets and asynchronous file system operations (among other features). However, as a full-featured library it includes much more than what is needed and could conflict with other features of \CFA unless significant effort is made to merge them together. - -\paragraph{Event-Engine} -Laying on top of the asynchronous interface layer is the event-engine. This engine is responsible for multiplexing (batching) the synchronous I/O requests into an asynchronous I/O request and demultiplexing the results onto appropriate blocked threads. This step can be straightforward for the simple cases, but can become quite complex. Decisions that need to be made include : whether to poll from a seperate kernel thread or a regularly scheduled user thread, what should be the ordering used when results satisfy many requests, how to handle threads waiting for multiple operations, etc. +One fundamental part for converting blocking I/O operations into non-blocking ones is having an underlying asynchronous I/O interface to direct the I/O operations. +While there exists many different APIs for asynchronous I/O, it is not part of this proposal to create a novel API. +It is sufficient to make one work in the complex context of the \CFA runtime. +\uC uses the $select$\cite{select} as its interface, which handles ttys, pipes and sockets, but not disk. +$select$ entails significant complexity and is being replaced in UNIX operating-systems, which make it a less interesting alternative. +Another popular interface is $epoll$\cite{epoll}, which is supposed to be cheaper than $select$. +However, $epoll$ also does not handle the file system and anectodal evidence suggest it has problem with linux pipes and $TTY$s. +A popular cross-platform alternative is $libuv$\cite{libuv}, which offers asynchronous sockets and asynchronous file system operations (among other features). +However, as a full-featured library it includes much more than I need and could conflict with other features of \CFA unless significant effort is made to merge them together. +A very recent alternative that I am investigating is $io_uring$\cite{io_uring}. +It claims to address some of the issues with $epoll$ and my early investigating suggest that the claim is accurate. +$io_uring$ uses a much more general approach where system calls are register to a queue and later executed by the kernel, rather than relying on system calls to return an error instead of blocking and subsequently waiting for changes on file descriptors. +I believe this approach allows for fewer problems, \eg the manpage for $open$\cite{open} states: +\begin{quote} + Note that [the $O_NONBLOCK$ flag] has no effect for regular files and block devices; + that is, I/O operations will (briefly) block when device activity is required, regardless of whether $O_NONBLOCK$ is set. + Since $O_NONBLOCK$ semantics might eventually be implemented, applications should not depend upon blocking behavior when specifying this flag for regular files and block devices. +\end{quote} +This makes approach based on $epoll$/$select$ less reliable since they may not work for every file descriptors. +For this reason, I plan to use $io_uring$ as the OS abstraction for the \CFA runtime, unless further work shows problems I haven't encountered yet. +However, only a small subset of the features are available in Ubuntu as of April 2020\cite{wiki:ubuntu-linux}, which will limit performance comparisons. +I do not believe this will affect the comparison result. + +\paragraph{Event Engine} +Laying on top of the asynchronous interface layer is the event engine. +This engine is responsible for multiplexing (batching) the synchronous I/O requests into asynchronous I/O requests and demultiplexing the results to appropriate blocked user threads. +This step can be straightforward for simple cases, but becomes quite complex when there are thousands of user threads performing both reads and writes, possibly on overlapping file descriptors. +Decisions that need to be made include: +\begin{enumerate} +\item +whether to poll from a separate kernel thread or a regularly scheduled user thread, +\item +what should be the ordering used when results satisfy many requests, +\item +how to handle threads waiting for multiple operations, etc. +\end{enumerate} \paragraph{Interface} -Finally, for these components to be available, it is necessary to expose them through a synchronous interface. The interface can be novel but it is preferrable to match the existing POSIX interface in order to be compatible with existing code. Matching allows C programs written using this interface to be transparently converted to \CFA with minimal effeort. Where this is not applicable, a novel interface will be created to fill the gaps. +Finally, for these non-blocking I/O components to be available, it is necessary to expose them through a synchronous interface because that is the \CFA concurrent programming style. +The interface can be novel but it is preferable to match the existing POSIX interface when possible to be compatible with existing code. +Matching allows C programs written using this interface to be transparently converted to \CFA with minimal effort. +Where new functionality is needed, I will create a novel interface to fill gaps and provide advanced features. @@ -268,10 +488,20 @@ % =============================================================================== \section{Discussion} - +I believe that runtime system and scheduling are still open topics. +Many ``state of the art'' production frameworks still use single threaded event-loops because of performance considerations, \eg \cite{nginx-design}, and, to my knowledge, no wideyl available system language offers modern threading facilities. +I believe the proposed work offers a novel runtime and scheduling package, where existing work only offers fragments that users must assemble themselves when possible. % =============================================================================== % =============================================================================== \section{Timeline} - +\begin{center} +\begin{tabular}{ | r @{--} l | p{4in} | } +\hline May 2020 & October 2020 & Creation of the performance benchmark. \\ +\hline November 2020 & March 2021 & Completion of the implementation. \\ +\hline March 2021 & April 2021 & Final Performance experiments. \\ +\hline May 2021 & August 2021 & Thesis writing and defense. \\ +\hline +\end{tabular} +\end{center} % B I B L I O G R A P H Y Index: doc/theses/thierry_delisle_PhD/comp_II/comp_II_PAB.tex =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/comp_II_PAB.tex (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ doc/theses/thierry_delisle_PhD/comp_II/comp_II_PAB.tex (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,525 @@ +\documentclass[11pt]{article} +\usepackage{fullpage} +\usepackage[T1]{fontenc} +\usepackage[utf8]{inputenc} +\usepackage{xspace} +\usepackage{xcolor} +\usepackage{graphicx} +\usepackage{epic,eepic} +\usepackage{listings} % for code listings +\usepackage{glossaries} +\usepackage{textcomp} +% cfa macros used in the document +\input{common} + +\setlist{topsep=6pt,parsep=0pt} % global reduce spacing between points +\newcommand{\uC}{$\mu$\CC} +\usepackage[breaklinks=true,pagebackref=true,hidelinks]{hyperref} +\urlstyle{rm} +\setlength{\abovecaptionskip}{5pt plus 3pt minus 2pt} +\lstMakeShortInline$% % single-character for \lstinline +%\usepackage[margin=1in]{geometry} +%\usepackage{float} +%\usepackage{breakurl} + +\input{glossary} + +\CFAStyle % use default CFA format-style + +\title{ + \Huge \vspace*{1in} The \CFA Scheduler\\ + \huge \vspace*{0.25in} PhD Comprehensive II Research Proposal + \vspace*{1in} +} + +\author{ + \huge Thierry Delisle \vspace*{5pt} \\ + \Large \texttt{tdelisle@uwaterloo.ca} \vspace*{5pt} \\ + \Large Cheriton School of Computer Science \\ + \Large University of Waterloo +} + +\date{ + \today +} + +\begin{document} +\maketitle +\cleardoublepage + +\newcommand{\cit}{\textsuperscript{[Citation Needed]}\xspace} +\newcommand{\TODO}{{\large\bf\color{red} TODO: }\xspace} + +% =============================================================================== +% =============================================================================== + +\tableofcontents + +% =============================================================================== +% =============================================================================== +\newpage +\section{Introduction} +\subsection{\CFA and the \CFA concurrency package} +\CFA~\cite{Moss18} is a modern, polymorphic, non-object-oriented, concurrent, backwards-compatible extension of the C programming language. +It aims to add high-productivity features while maintaining the predictable performance of C. +As such, concurrency in \CFA~\cite{Delisle19} aims to offer simple and safe high-level tools while still allowing performant code. +\CFA concurrent code is written in the synchronous programming paradigm but uses \glspl{uthrd} in order to achieve the simplicity and maintainability of synchronous programming without sacrificing the efficiency of asynchronous programing. +As such, the \CFA \newterm{scheduler} is a preemptive user-level scheduler that maps \glspl{uthrd} onto \glspl{kthrd}. + +\newterm{Scheduling} occurs when execution switches from one thread to another, where the second thread is implicitly chosen by the scheduler. +This scheduling is an indirect handoff, as opposed to generators and coroutines which explicitly switch to the next generator and coroutine respectively. +The cost of switching between two threads for an indirect handoff has two components: +\begin{enumerate} +\item +the cost of actually context-switching, \ie changing the relevant registers to move execution from one thread to the other, +\item +and the cost of scheduling, \ie deciding which thread to run next among all the threads ready to run. +\end{enumerate} +The first cost is generally constant and fixed\footnote{Affecting the constant context-switch cost is whether it is done in one step, after the scheduling, or in two steps, context-switching to a fixed third-thread before scheduling.}, while the scheduling cost can vary based on the system state. +Adding multiple \glspl{kthrd} does not fundamentally change the scheduler semantics or requirements, it simply adds new correctness requirements, \ie \newterm{linearizability}\footnote{Meaning however fast the CPU threads run, there is an equivalent sequential order that gives the same result.}, and a new dimension to performance: scalability, where scheduling cost now also depends on contention. + +The more threads switch, the more the administration cost of scheduling becomes noticeable. +It is therefore important to build a scheduler with the lowest possible cost and latency. +Another important consideration is \newterm{fairness}. +In principle, scheduling should give the illusion of perfect fairness, where all threads ready to run are running \emph{simultaneously}. +While the illusion of simultaneity is easier to reason about, it can break down if the scheduler allows too much unfairness. +Therefore, the scheduler should offer as much fairness as needed to guarantee eventual progress, but use unfairness to help performance. +In practice, threads must wait in turn but there can be advantages to unfair scheduling, similar to the the express cash-register at a grocery store. + +The goal of this research is to produce a scheduler that is simple for programmers to understand and offers good performance. +Here understandability does not refer to the API but to how much scheduling concerns programmers need to take into account when writing a \CFA concurrent package. +Therefore, the main goal of this proposal is : +\begin{quote} +The \CFA scheduler should be \emph{viable} for \emph{any} workload. +\end{quote} + +For a general purpose scheduler, it is impossible to produce an optimal algorithm as it would require knowledge of the future behaviour of threads. +As such, scheduling performance is generally either defined by the best case scenario, \ie a workload to which the scheduler is tailored, or the worst case scenario, \ie the scheduler behaves no worst than \emph{X}. +For this proposal, the performance is evaluated using the second approach to allow \CFA programmers to rely on scheduling performance. +Because there is no optimal scheduler, ultimately \CFA may allow programmers to write their own scheduler; but that is not the subject of this proposal, which considers only the default scheduler. +As such, it is important that only programmers with exceptionally high performance requirements should need to write their own scheduler and replace the scheduler in this proposal. + +To achieve the \CFA scheduling goal includes: +\begin{enumerate} +\item +producing a scheduling strategy with sufficient fairness guarantees, +\item +creating an abstraction layer over the operating system to handle kernel-threads spinning unnecessarily, +\item +scheduling blocking I/O operations, +\item +and writing sufficient library tools to allow developers to indirectly use the scheduler, either through tuning knobs or replacing the default scheduler. +\end{enumerate} + +% =============================================================================== +% =============================================================================== + +\section{\CFA Scheduling} +To schedule user-level threads across all workloads, the scheduler has a number of requirements: + +\paragraph{Correctness} As with any other concurrent data structure or algorithm, the correctness requirement is paramount. +The scheduler cannot allow threads to be dropped from the ready queue, \ie scheduled but never run, or be executed multiple times when only being scheduled once. +Since \CFA concurrency has no spurious wakeup, this definition of correctness also means the scheduler should have no spurious wakeup. +The \CFA scheduler must be correct. + +\paragraph{Performance} The performance of a scheduler can generally be measured in terms of scheduling cost, scalability and latency. +\newterm{Scheduling cost} is the cost to switch from one thread to another, as mentioned above. +For simple applications, where a single kernel thread does most of the scheduling, it is generally the dominating cost. +\newterm{Scalability} is the cost of adding multiple kernel threads because it increases the time for context switching because of contention by multiple threads accessing shared resources, \eg the ready queue. +Finally, \newterm{tail latency} is service delay and relates to thread fairness. +Specifically, latency measures how long a thread waits to run once scheduled and is evaluated in the worst case. +The \CFA scheduler should offer good performance for all three metrics. + +\paragraph{Fairness} Like performance, this requirement has several aspect : eventual progress, predictability and performance reliability. +\newterm{Eventual progress} guarantees every scheduled thread is eventually run, \ie prevent starvation. +As a hard requirement, the \CFA scheduler must guarantee eventual progress, otherwise the above mentioned illusion of simultaneous execution is broken and the scheduler becomes much more complex to reason about. +\newterm{Predictability} and \newterm{reliability} means similar workloads achieve similar performance and programmer execution intuition is respected. +For example, a thread that yields aggressively should not run more often then other tasks. +While this is intuitive, it does not hold true for many work-stealing or feedback based schedulers. +The \CFA scheduler must guarantee eventual progress and should be predictable and offer reliable performance. + +\paragraph{Efficiency} Finally, efficient usage of CPU resources is also an important requirement and is discussed in depth towards the end of the proposal. +\newterm{Efficiency} means avoiding using CPU cycles when there are no threads to run, and conversely, use all CPUs available when the workload can benefit from it. +Balancing these two states is where the complexity lies. +The \CFA scheduler should be efficient with respect to the underlying (shared) computer. + +\bigskip To achieve these requirements, I can reject two broad types of scheduling strategies : feedback-based and priority schedulers. + +\subsection{Feedback-Based Schedulers} +Many operating systems use schedulers based on feedback in some form, \eg measuring how much CPU a particular thread has used\footnote{Different metrics can be measured but it is not relevant to the discussion.} and schedule threads based on this metric. +These strategies are sensible for operating systems but rely on two assumptions for the workload: + +\begin{enumerate} + \item Threads live long enough for useful feedback information to be to gathered. + \item Threads belong to multiple users so fairness across threads is insufficient. +\end{enumerate} + +While these two assumptions generally hold for operating systems, they may not for user-level threading. +Since \CFA has the explicit goal of allowing many smaller threads, this can naturally lead to threads with much shorter lifetimes that are only scheduled a few times. +Scheduling strategies based on feedback cannot be effective in these cases because there is no opportunity to measure the metrics that underlie the algorithm. +Note, the problem of \newterm{feedback convergence} (reacting too slowly to scheduling events) is not specific to short lived threads but can also occur with threads that show drastic changes in scheduling, \eg threads running for long periods of time and then suddenly blocking and unblocking quickly and repeatedly. + +In the context of operating systems, these concerns can be overshadowed by a more pressing concern : security. +When multiple users are involved, it is possible some users are malevolent and try to exploit the scheduling strategy to achieve some nefarious objective. +Security concerns mean more precise and robust fairness metrics must be used to guarantee fairness across processes created by users as well as threads created within a process. +In the case of the \CFA scheduler, every thread runs in the same user space and is controlled by the same user. +Fairness across users is therefore a given and it is then possible to safely ignore the possibility that threads are malevolent. +This approach allows for a much simpler fairness metric and in this proposal \emph{fairness} is defined as: when multiple threads are cycling through the system, the total ordering of threads being scheduled, \ie pushed onto the ready-queue, should not differ much from the total ordering of threads being executed, \ie popped from the ready-queue. + +Since feedback is not necessarily feasible within the lifetime of all threads and a simple fairness metric can be used, the scheduling strategy proposed for the \CFA runtime does not use per-threads feedback. +Feedback in general is not rejected for secondary concerns like idle sleep for kernel threads, but no feedback is used to decide which thread to run next. + +\subsection{Priority Schedulers} +Another broad category of schedulers are priority schedulers. +In these scheduling strategies, threads have priorities and the runtime schedules the threads with the highest priority before scheduling other threads. +Threads with equal priority are scheduled using a secondary strategy, often something simple like round-robin or FIFO. +A consequence of priority is that, as long as there is a thread with a higher priority that desires to run, a thread with a lower priority does not run. +This possible starving of threads can dramatically increase programming complexity since starving threads and priority inversion (prioritizing a lower priority thread) can both lead to serious problems. + +An important observation is that threads do not need to have explicit priorities for problems to occur. +Indeed, any system with multiple ready-queues that attempts to exhaust one queue before accessing the other queues, essentially provide implicit priority, which can encounter starvation problems. +For example, a popular scheduling strategy that suffers from implicit priorities is work stealing. +\newterm{Work stealing} is generally presented as follows: +\begin{enumerate} + \item Each processor has a list of ready threads. + \item Each processor runs threads from its ready queue first. + \item If a processor's ready queue is empty, attempt to run threads from some other processor's ready queue. +\end{enumerate} + +In a loaded system\footnote{A \newterm{loaded system} is a system where threads are being run at the same rate they are scheduled.}, if a thread does not yield, block, or preempt for an extended period of time, threads on the same processor's list starve if no other processors exhaust their list. + +Since priorities can be complex for programmers to incorporate into their execution intuition, the scheduling strategy proposed for the \CFA runtime does not use a strategy with either implicit or explicit thread priorities. + +\subsection{Schedulers without feedback or priorities} +This proposal conjectures that is is possible to construct a default scheduler for the \CFA runtime that offers good scalability and a simple fairness guarantee that is easy for programmers to reason about. +The simplest fairness guarantee is FIFO ordering, \ie threads scheduled first run first. +However, enforcing FIFO ordering generally conflicts with scalability across multiple processors because of the additional synchronization. +Thankfully, strict FIFO is not needed for sufficient fairness. +Since concurrency is inherently non-deterministic, fairness concerns in scheduling are only a problem if a thread repeatedly runs before another thread can run. +Some relaxation is possible because non-determinism means programmers already handle ordering problems to produce correct code and hence rely on weak guarantees, \eg that a specific thread will \emph{eventually} run. +Since some reordering does not break correctness, the FIFO fairness guarantee can be significantly relaxed without causing problems. +For this proposal, the target guarantee is that the \CFA scheduler provides \emph{probable} FIFO ordering, which allows reordering but makes it improbable that threads are reordered far from their position in total ordering. + +The \CFA scheduler fairness is defined as follows: +\begin{itemize} + \item Given two threads $X$ and $Y$, the odds that thread $X$ runs $N$ times \emph{after} thread $Y$ is scheduled but \emph{before} it is run, decreases exponentially with regard to $N$. +\end{itemize} +While this is not a bounded guarantee, the probability that unfairness persist for long periods of times decreases exponentially, making persisting unfairness virtually impossible. + +% =============================================================================== +% =============================================================================== +\section{Proposal Details} + +\subsection{Central Ready Queue} \label{sec:queue} +A central ready queue can be built from a FIFO queue, where user threads are pushed onto the queue when they are ready to run, and processors (kernel-threads acting as virtual processors) pop the user threads from the queue and execute them. +Alistarh \etal~\cite{alistarh2018relaxed} show it is straightforward to build a relaxed FIFO list that is fast and scalable for loaded or overloaded systems. +The described queue uses an array of underlying strictly FIFO queues as shown in Figure~\ref{fig:base}\footnote{For this section, the number of underlying queues is assumed to be constant. +Section~\ref{sec:resize} discusses resizing the array.}. +Pushing new data is done by selecting one of these underlying queues at random, recording a timestamp for the operation and pushing to the selected queue. +Popping is done by selecting two queues at random and popping from the queue with the oldest timestamp. +A higher number of underlying queues leads to less contention on each queue and therefore better performance. +In a loaded system, it is highly likely the queues are non-empty, \ie several tasks are on each of the underlying queues. +This means that selecting a queue at random to pop from is highly likely to yield a queue with available items. +In Figure~\ref{fig:base}, ignoring the ellipsis, the chances of getting an empty queue is 2/7 per pick, meaning two random picks yield an item approximately 9 times out of 10. + +\begin{figure} + \begin{center} + \input{base} + \end{center} + \caption{Relaxed FIFO list at the base of the scheduler: an array of strictly FIFO lists. +The timestamp is in all nodes and cell arrays.} + \label{fig:base} +\end{figure} + +\begin{figure} + \begin{center} + \input{empty} + \end{center} + \caption{``More empty'' state of the queue: the array contains many empty cells.} + \label{fig:empty} +\end{figure} + +When the ready queue is \emph{more empty}, \ie several of the queues are empty, selecting a random queue for popping is less likely to yield a successful selection and more attempts are needed, resulting in a performance degradation. +Figure~\ref{fig:empty} shows an example with fewer elements, where the chances of getting an empty queue is 5/7 per pick, meaning two random picks yield an item only half the time. +Since the ready queue is not empty, the pop operation \emph{must} find an element before returning and therefore must retry. +Note, the popping kernel thread has no work to do, but CPU cycles are wasted both for available user and kernel threads during the pop operation as the popping thread is using a CPU. +Overall performance is therefore influenced by the contention on the underlying queues and pop performance is influenced by the item density. + +This leads to four performance cases for the centralized ready-queue, as depicted in Table~\ref{tab:perfcases}. +The number of processors (many or few) refers to the number of kernel threads \emph{actively} attempting to pop user threads from the queues, not the total number of kernel threads. +The number of threads (many or few) refers to the number of user threads ready to be run. +Many threads means they outnumber processors significantly and most underlying queues have items, few threads mean there are barely more threads than processors and most underlying queues are empty. +Cases with fewer threads than processors are discussed in Section~\ref{sec:sleep}. + +\begin{table} + \begin{center} + \begin{tabular}{|r|l|l|} + \cline{2-3} + \multicolumn{1}{r|}{} & \multicolumn{1}{c|}{Many Processors} & \multicolumn{1}{c|}{Few Processors} \\ + \hline + Many Threads & A: good performance & B: good performance \\ + \hline + Few Threads & C: worst performance & D: poor performance \\ + \hline + \end{tabular} + \end{center} + \caption{Expected performance of the relaxed FIFO list in different cases.} + \label{tab:perfcases} +\end{table} + +Performance can be improved in case~D (Table~\ref{tab:perfcases}) by adding information to help processors find which inner queues are used. +This addition aims to avoid the cost of retrying the pop operation but does not affect contention on the underlying queues and can incur some management cost for both push and pop operations. +The approach used to encode this information can vary in density and be either global or local. +\newterm{Density} means the information is either packed in a few cachelines or spread across several cachelines, and \newterm{local information} means each thread uses an independent copy instead of a single global, \ie common, source of information. + +For example, Figure~\ref{fig:emptybit} shows a dense bitmask to identify which inner queues are currently in use. +This approach means processors can often find user threads in constant time, regardless of how many underlying queues are empty. +Furthermore, modern x86 CPUs have extended bit manipulation instructions (BMI2) that allow using the bitmask with very little overhead compared to the randomized selection approach for a filled ready queue, offering good performance even in cases with many empty inner queues. +However, this technique has its limits: with a single word\footnote{Word refers here to however many bits can be written atomically.} bitmask, the total number of underlying queues in the ready queue is limited to the number of bits in the word. +With a multi-word bitmask, this maximum limit can be increased arbitrarily, but it is not possible to check if the queue is empty by reading the bitmask atomically. + +Finally, a dense bitmap, either single or multi-word, causes additional problems in case C (Table 1), because many processors are continuously scanning the bitmask to find the few available threads. +This increased contention on the bitmask(s) reduces performance because of cache misses after updates and the bitmask is updated more frequently by the scanning processors racing to read and/or update that information. +This increased update frequency means the information in the bitmask is more often stale before a processor can use it to find an item, \ie mask read says there are available user threads but none on queue. + +\begin{figure} + \begin{center} + {\resizebox{0.8\textwidth}{!}{\input{emptybit}}} + \end{center} + \caption{``More empty'' queue with added bitmask to indicate which array cells have items.} + \label{fig:emptybit} +\end{figure} + +Figure~\ref{fig:emptytree} shows another approach using a hierarchical tree data-structure to reduce contention and has been shown to work in similar cases~\cite{ellen2007snzi}\footnote{This particular paper seems to be patented in the US. +How does that affect \CFA? Can I use it in my work?}. +However, this approach may lead to poorer performance in case~B (Table~\ref{tab:perfcases}) due to the inherent pointer chasing cost and already low contention cost in that case. + +\begin{figure} + \begin{center} + {\resizebox{0.8\textwidth}{!}{\input{emptytree}}} + \end{center} + \caption{``More empty'' queue with added binary search tree indicate which array cells have items.} + \label{fig:emptytree} +\end{figure} + +Finally, a third approach is to use dense information, similar to the bitmap, but have each thread keep its own independent copy of it. +While this approach can offer good scalability \emph{and} low latency, the liveliness of the information can become a problem. +In the simple cases, local copies of which underlying queues are empty can become stale and end-up not being useful for the pop operation. +A more serious problem is that reliable information is necessary for some parts of this algorithm to be correct. +As mentioned in this section, processors must know \emph{reliably} whether the list is empty or not to decide if they can return \texttt{NULL} or if they must keep looking during a pop operation. +Section~\ref{sec:sleep} discusses another case where reliable information is required for the algorithm to be correct. + +\begin{figure} + \begin{center} + \input{emptytls} + \end{center} + \caption{``More empty'' queue with added per processor bitmask to indicate which array cells have items.} + \label{fig:emptytls} +\end{figure} + +There is a fundamental tradeoff among these approach. +Dense global information about empty underlying queues helps zero-contention cases at the cost of high-contention case. +Sparse global information helps high-contention cases but increases latency in zero-contention-cases, to read and ``aggregate'' the information\footnote{Hierarchical structures, \eg binary search tree, effectively aggregate information but follow pointer chains, learning information at each node. +Similarly, other sparse schemes need to read multiple cachelines to acquire all the information needed.}. +Finally, dense local information has both the advantages of low latency in zero-contention cases and scalability in high-contention cases, however the information can become stale making it difficult to use to ensure correctness. +The fact that these solutions have these fundamental limits suggest to me a better solution that attempts to combine these properties in an interesting ways. +Also, the lock discussed in Section~\ref{sec:resize} allows for solutions that adapt to the number of processors, which could also prove useful. + +\paragraph{Objectives and Existing Work} + +How much scalability is actually needed is highly debatable. +\emph{libfibre}~\cite{libfibre} has compared favorably to other schedulers in webserver tests~\cite{Karsten20} and uses a single atomic counter in its scheduling algorithm similarly to the proposed bitmask. +As such, the single atomic instruction on a shared cacheline may be sufficiently performant. + +I have built a prototype of this ready queue in the shape of a data queue, \ie nodes on the queue are structures with a single int representing a thread and intrusive data fields. +Using this prototype I ran preliminary performance experiments that confirm the expected performance in Table~\ref{tab:perfcases}. +However, these experiments only offer a hint at the actual performance of the scheduler since threads form more complex operations than simple integer nodes, \eg threads are not independent of each other, when a thread blocks some other thread must intervene to wake it. + +I have also integrated this prototype into the \CFA runtime, but have not yet created performance experiments to compare results, as creating one-to-one comparisons between the prototype and the \CFA runtime will be complex. + +\subsection{Dynamic Resizing} \label{sec:resize} + +\begin{figure} + \begin{center} + \input{system} + \end{center} + \caption{Global structure of the \CFA runtime system.} + \label{fig:system} +\end{figure} + +The \CFA runtime system groups processors together as \newterm{clusters}, as shown in Figure~\ref{fig:system}. +Threads on a cluster are always scheduled on one of the processors of the cluster. +Currently, the runtime handles dynamically adding and removing processors from clusters at any time. +Since this is part of the existing design, the proposed scheduler must also support this behaviour. +However, dynamically resizing a cluster is considered a rare event associated with setup, tear down and major configuration changes. +This assumption is made both in the design of the proposed scheduler as well as in the original design of the \CFA runtime system. +As such, the proposed scheduler must honour the correctness of this behaviour but does not have any performance objectives with regard to resizing a cluster. +How long adding or removing processors take and how much this disrupts the performance of other threads is considered a secondary concern since it should be amortized over long period of times. +However, as mentioned in Section~\ref{sec:queue}, contention on the underlying queues can have a direct impact on performance. +The number of underlying queues must therefore be adjusted as the number of processors grows or shrinks. +Since the underlying queues are stored in a dense array, changing the number of queues requires resizing the array and expanding the array requires moving it, which can introduce memory reclamation problems if not done correctly. + +\begin{figure} + \begin{center} + \input{resize} + \end{center} + \caption{Copy of data structure shown in Figure~\ref{fig:base}.} + \label{fig:base2} +\end{figure} + +It is important to note how the array is used in this case. +While the array cells are modified by every push and pop operation, the array itself, \ie the pointer that would change when resized, is only read during these operations. +Therefore the use of this pointer can be described as frequent reads and infrequent writes. +This description effectively matches with the description of a reader-writer lock, infrequent but invasive updates among frequent read operations. +In the case of the ready queue described above, read operations are operations that push or pop from the ready queue but do not invalidate any references to the ready queue data structures. +Writes on the other hand would add or remove inner queues, invalidating references to the array of inner queues in a process. +Therefore, the current proposed approach to this problem is to add a per-cluster reader-writer lock around the ready queue to prevent restructuring of the ready-queue data-structure while threads are being pushed or popped. + +There are possible alternatives to the reader-writer lock solution. +This problem is effectively a memory reclamation problem and as such there is a large body of research on the subject~\cite{michael2004hazard, brown2015reclaiming}. +However, the reader-write lock-solution is simple and can be leveraged to solve other problems (\eg processor ordering and memory reclamation of threads), which makes it an attractive solution. + +\paragraph{Objectives and Existing Work} +The lock must offer scalability and performance on par with the actual ready-queue in order not to introduce a new bottleneck. +I have already built a lock that fits the desired requirements and preliminary testing show scalability and performance that exceed the target. +As such, I do not consider this lock to be a risk for this project. + +\subsection{Idle Sleep} \label{sec:sleep} + +\newterm{Idle sleep} is the process of putting processors to sleep when they have no threads to execute. +In this context, processors are kernel threads and sleeping refers to asking the kernel to block a thread. +This operation can be achieved with either thread synchronization operations like $pthread_cond_wait$ or using signal operations like $sigsuspend$. +The goal of putting idle processors to sleep is: +\begin{enumerate} +\item +reduce contention on the ready queue, since the otherwise idle processors generally contend trying to pop items from the queue, +\item +give back unneeded CPU time associated with a process to other user processors executing on the computer, +\item +and reduce energy consumption in cases where more idle kernel-threads translate to idle CPUs, which can cycle down. +\end{enumerate} +Support for idle sleep broadly involves calling the operating system to block the kernel thread and handling the race between a blocking thread and the waking thread, and handling which kernel thread should sleep or wake up. + +When a processor decides to sleep, there is a race that occurs between it signalling that is going to sleep (so other processors can find sleeping processors) and actually blocking the kernel thread. +This operation is equivalent to the classic problem of missing signals when using condition variables: the ``sleepy'' processor indicates its intention to block but has not yet gone to sleep when another processor attempts to wake it up. +The waking-up operation sees the blocked process and signals it, but the blocking process is racing to sleep so the signal is missed. +In cases where kernel threads are managed as processors on the current cluster, loosing signals is not necessarily critical, because at least some processors on the cluster are awake and may check for more processors eventually. +Individual processors always finish scheduling user threads before looking for new work, which means that the last processor to go to sleep cannot miss threads scheduled from inside the cluster (if they do, that demonstrates the ready queue is not linearizable). +However, this guarantee does not hold if threads are scheduled from outside the cluster, either due to an external event like timers and I/O, or due to a user (or kernel) thread migrating from a different cluster. +In this case, missed signals can lead to the cluster deadlocking\footnote{Clusters should only deadlock in cases where a \CFA programmer \emph{actually} write \CFA code that leads to a deadlock.}. +Therefore, it is important that the scheduling of threads include a mechanism where signals \emph{cannot} be missed. +For performance reasons, it can be advantageous to have a secondary mechanism that allows signals to be missed in cases where it cannot lead to a deadlock. +To be safe, this process must include a ``handshake'' where it is guaranteed that either~: the sleeping processor notices that a user thread is scheduled after the sleeping processor signalled its intent to block or code scheduling threads sees the intent to sleep before scheduling and be able to wake-up the processor. +This matter is complicated by the fact that pthreads and Linux offer few tools to implement this solution and no guarantee of ordering of threads waking up for most of these tools. + +Another important issue is avoiding kernel threads sleeping and waking frequently because there is a significant operating-system cost. +This scenario happens when a program oscillates between high and low activity, needing most and then less processors. +A possible partial solution is to order the processors so that the one which most recently went to sleep is woken up. +This allows other sleeping processors to reach deeper sleep state (when these are available) while keeping ``hot'' processors warmer. +Note that while this generally means organizing the processors in a stack, I believe that the unique index provided in my reader-writer lock can be reused to strictly order the waking processors, causing a mostly LIFO order. +While a strict LIFO stack is probably better, the processor index could prove useful for other reasons, while still offering a sufficiently LIFO ordering. + +A final important aspect of idle sleep is when should processors make the decision to sleep and when is it appropriate for sleeping processors to be woken up. +Processors that are unnecessarily unblocked lead to unnecessary contention, CPU usage, and power consumption, while too many sleeping processors can lead to sub-optimal throughput. +Furthermore, transitions from sleeping to awake and vice-versa also add unnecessary latency. +There is already a wealth of research on the subject~\cite{schillings1996engineering, wiki:thunderherd} and I may use an existing approach for the idle-sleep heuristic in this project, \eg~\cite{Karsten20}. + +\subsection{Asynchronous I/O} + +The final aspect of this proposal is asynchronous I/O. +Without it, user threads that execute I/O operations block the underlying kernel thread, which leads to poor throughput. +It is preferable to block the user thread performing the I/O and reuse the underlying kernel-thread to run other ready user threads. +This approach requires intercepting user-thread calls to I/O operations, redirecting them to an asynchronous I/O interface, and handling the multiplexing/demultiplexing between the synchronous and asynchronous API. +As such, there are three components needed to implemented support for asynchronous I/O: +\begin{enumerate} +\item +an OS abstraction layer over the asynchronous interface, +\item +an event-engine to (de)multiplex the operations, +\item +and a synchronous interface for users to use. +\end{enumerate} +None of these components currently exist in \CFA and I will need to build all three for this project. + +\paragraph{OS Abstraction} +One fundamental part for converting blocking I/O operations into non-blocking ones is having an underlying asynchronous I/O interface to direct the I/O operations. +While there exists many different APIs for asynchronous I/O, it is not part of this proposal to create a novel API. +It is sufficient to make one work in the complex context of the \CFA runtime. +\uC uses the $select$~\cite{select} as its interface, which handles ttys, pipes and sockets, but not disk. +$select$ entails significant complexity and is being replaced in UNIX operating-systems, which make it a less interesting alternative. +Another popular interface is $epoll$~\cite{epoll}, which is supposed to be cheaper than $select$. +However, $epoll$ also does not handle the file system and anecdotal evidence suggest it has problem with linux pipes and $TTY$s. +A popular cross-platform alternative is $libuv$~\cite{libuv}, which offers asynchronous sockets and asynchronous file system operations (among other features). +However, as a full-featured library it includes much more than I need and could conflict with other features of \CFA unless significant effort is made to merge them together. +A very recent alternative that I am investigating is $io_uring$~\cite{io_uring}. +It claims to address some of the issues with $epoll$ and my early investigating suggest that the claim is accurate. +$io_uring$ uses a much more general approach where system calls are register to a queue and later executed by the kernel, rather than relying on system calls to return an error instead of blocking and subsequently waiting for changes on file descriptors. +I believe this approach allows for fewer problems, \eg the manpage for $open$~\cite{open} states: +\begin{quote} + Note that [the $O_NONBLOCK$ flag] has no effect for regular files and block devices; + that is, I/O operations will (briefly) block when device activity is required, regardless of whether $O_NONBLOCK$ is set. + Since $O_NONBLOCK$ semantics might eventually be implemented, applications should not depend upon blocking behavior when specifying this flag for regular files and block devices. +\end{quote} +This makes approach based on $epoll$/$select$ less reliable since they may not work for every file descriptors. +For this reason, I have started to use $io_uring$ as the OS abstraction for the \CFA runtime, until further work shows problems I have not encountered yet. +However, only a small subset of the features are available in Ubuntu as of April 2020~\cite{wiki:ubuntu-linux}, which limits performance comparisons. +The currently available features are sufficient to start basic socket performance experiments and comparisons. + +\paragraph{Event Engine} +Laying on top of the asynchronous interface layer is the event engine. +This engine is responsible for multiplexing (batching) the synchronous I/O requests into asynchronous I/O requests and demultiplexing the results to appropriate blocked user-threads. +This step can be straightforward for simple cases, but becomes quite complex when there are thousands of user threads performing both reads and writes, possibly on overlapping file descriptors. +Decisions that need to be made include: +\begin{enumerate} +\item +whether to poll from a separate kernel thread or a regularly scheduled user thread, +\item +what should be the ordering used when results satisfy many requests, +\item +how to handle threads waiting for multiple operations, etc. +\end{enumerate} + +\paragraph{Interface} +Finally, for these non-blocking I/O components to be available, it is necessary to expose them through a synchronous interface because that is the \CFA concurrent programming style. +The interface can add novel features but it is preferable to match the existing POSIX interface when possible to be compatible with existing code. +Matching allows C programs written using this interface to be transparently converted to \CFA with minimal effort. +Where new functionality is needed, I will create a novel interface extensions to fill gaps and provide advanced features. + + +% =============================================================================== +% =============================================================================== +\section{Discussion} +I believe that runtime systems and scheduling are still open topics. +Many ``state of the art'' production frameworks still use single threaded event-loops because of performance considerations, \eg~\cite{nginx-design}, and, to my knowledge, no widely available system language offers modern threading facilities. +I believe the proposed work offers a novel runtime and scheduling package embedded in the \CFA programming language, where existing work only offers fragments that users must assemble themselves when possible. + +% =============================================================================== +% =============================================================================== +\section{Timeline} +\begin{center} +\begin{tabular}{ | r @{--} l | p{4in} | } +\hline May 2020 & October 2020 & Creation of the performance benchmark. \\ +\hline November 2020 & March 2021 & Completion of the implementation. \\ +\hline March 2021 & April 2021 & Final Performance experiments. \\ +\hline May 2017 & August 2021 & Thesis writing and defense. \\ +\hline +\end{tabular} +\end{center} + +% B I B L I O G R A P H Y +% ----------------------------- +\cleardoublepage +\phantomsection % allows hyperref to link to the correct page +\addcontentsline{toc}{section}{\refname} +\lstDeleteShortInline$% turn off as $ used in bibliography entries +\bibliographystyle{plain} +\bibliography{pl,local} + +% G L O S S A R Y +% ----------------------------- +\cleardoublepage +\phantomsection % allows hyperref to link to the correct page +\addcontentsline{toc}{section}{Glossary} +\printglossary + +\end{document} Index: doc/theses/thierry_delisle_PhD/comp_II/img/base.fig =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/img/base.fig (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/img/base.fig (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,91 +1,11 @@ -#FIG 3.2 Produced by xfig version 3.2.7a +#FIG 3.2 Produced by xfig version 3.2.5c Landscape Center Inches -Letter +Letter 100.00 Single -2 1200 2 -6 2400 3075 3000 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 3335 2850 3075 2550 3075 2400 3335 2550 3595 2850 3595 - 3000 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 4200 2700 3600 --6 -6 2400 2175 3000 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 2435 2850 2175 2550 2175 2400 2435 2550 2695 2850 2695 - 3000 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 3375 2700 2700 --6 -6 3600 2175 4200 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 4200 2435 4050 2175 3750 2175 3600 2435 3750 2695 4050 2695 - 4200 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 3900 3375 3900 2700 --6 -6 3600 3075 4200 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 4200 3335 4050 3075 3750 3075 3600 3335 3750 3595 4050 3595 - 4200 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 3900 4200 3900 3600 --6 -6 4200 3075 4800 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 4800 3335 4650 3075 4350 3075 4200 3335 4350 3595 4650 3595 - 4800 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 4500 4200 4500 3600 --6 -6 4800 3075 5400 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 3335 5250 3075 4950 3075 4800 3335 4950 3595 5250 3595 - 5400 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 4200 5100 3600 --6 -6 4800 2175 5400 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 2435 5250 2175 4950 2175 4800 2435 4950 2695 5250 2695 - 5400 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 3375 5100 2700 --6 -6 4800 1275 5400 2475 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 1535 5250 1275 4950 1275 4800 1535 4950 1795 5250 1795 - 5400 1535 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 2475 5100 1800 --6 -6 6000 2175 6600 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 6600 2435 6450 2175 6150 2175 6000 2435 6150 2695 6450 2695 - 6600 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 6300 3375 6300 2700 --6 -6 6000 3075 6600 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 6600 3335 6450 3075 6150 3075 6000 3335 6150 3595 6450 3595 - 6600 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 6300 4200 6300 3600 --6 6 6750 4125 7050 4275 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6825 4200 20 20 6825 4200 6845 4200 @@ -93,4 +13,24 @@ 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6975 4200 20 20 6975 4200 6995 4200 -6 +6 2400 2100 3000 2700 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 2400 300 300 2700 2400 3000 2400 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 2400 2475 3000 2475 +4 1 0 50 -1 0 11 0.0000 2 120 210 2700 2650 TS\001 +-6 +6 2400 3000 3000 3600 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 3300 300 300 2700 3300 3000 3300 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 2400 3375 3000 3375 +4 1 0 50 -1 0 11 0.0000 2 120 210 2700 3550 TS\001 +-6 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 3900 2400 300 300 3900 2400 4200 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 3900 3300 300 300 3900 3300 4200 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 1500 300 300 5100 1500 5400 1500 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 2400 300 300 5100 2400 5400 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 3300 300 300 5100 3300 5400 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 6300 2400 300 300 6300 2400 6600 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 6300 3300 300 300 6300 3300 6600 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 4509 3302 300 300 4509 3302 4809 3302 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 3000 3900 3000 4500 @@ -109,15 +49,39 @@ 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 2400 3900 7200 3900 7200 4500 2400 4500 2400 3900 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 3300 2700 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 3900 3300 3900 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 3900 4200 3900 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 2475 5100 1800 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 3300 5100 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 4200 5100 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 6300 3300 6300 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 6300 4200 6300 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 4200 2700 3600 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 2454 2520 2957 2520 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 2454 3417 2957 3417 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 2400 4350 3000 4350 -4 2 0 50 -1 0 12 0.0000 2 165 720 2100 4200 Array of\001 -4 2 0 50 -1 0 12 0.0000 2 150 540 2100 4425 Queues\001 -4 2 0 50 -1 0 12 0.0000 2 135 630 2100 3075 Threads\001 -4 2 0 50 -1 0 12 0.0000 2 165 450 2100 2850 Ready\001 -4 0 0 50 -1 0 11 0.0000 2 135 180 2595 3561 TS\001 -4 0 0 50 -1 0 11 0.0000 2 135 180 2595 2665 TS\001 -4 0 0 50 -1 0 11 0.0000 2 135 180 2595 4479 TS\001 + 2400 4275 3000 4275 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 4500 4200 4500 3600 +4 2 0 50 -1 0 12 0.0000 2 180 660 2100 4200 Array of\001 +4 2 0 50 -1 0 12 0.0000 2 165 600 2100 4425 Queues\001 +4 2 0 50 -1 0 12 0.0000 2 135 645 2100 3075 Threads\001 +4 2 0 50 -1 0 12 0.0000 2 180 525 2100 2850 Ready\001 +4 1 0 50 -1 0 11 0.0000 2 120 210 2700 4450 TS\001 Index: doc/theses/thierry_delisle_PhD/comp_II/img/empty.fig =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/img/empty.fig (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/img/empty.fig (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -8,28 +8,4 @@ -2 1200 2 -6 4800 3075 5400 4200 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 4200 5100 3600 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 3335 5250 3075 4950 3075 4800 3335 4950 3595 5250 3595 - 5400 3335 --6 -6 2400 2175 3000 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 2435 2850 2175 2550 2175 2400 2435 2550 2695 2850 2695 - 3000 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 3375 2700 2700 --6 -6 2400 3075 3000 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 3335 2850 3075 2550 3075 2400 3335 2550 3595 2850 3595 - 3000 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 4200 2700 3600 --6 6 6750 4125 7050 4275 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6825 4200 20 20 6825 4200 6845 4200 @@ -37,4 +13,7 @@ 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6975 4200 20 20 6975 4200 6995 4200 -6 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 3300 300 300 5100 3300 5400 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 2400 300 300 2700 2400 3000 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 3300 300 300 2700 3300 3000 3300 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 3000 3900 3000 4500 @@ -53,4 +32,13 @@ 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 2400 3900 7200 3900 7200 4500 2400 4500 2400 3900 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 3300 2700 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 4200 5100 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 4200 2700 3600 4 2 0 50 -1 0 12 0.0000 2 180 660 2100 4200 Array of\001 4 2 0 50 -1 0 12 0.0000 2 165 600 2100 4425 Queues\001 Index: doc/theses/thierry_delisle_PhD/comp_II/img/emptybit.fig =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/img/emptybit.fig (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/img/emptybit.fig (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -8,28 +8,4 @@ -2 1200 2 -6 4800 3075 5400 4200 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 4200 5100 3600 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 3335 5250 3075 4950 3075 4800 3335 4950 3595 5250 3595 - 5400 3335 --6 -6 2400 2175 3000 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 2435 2850 2175 2550 2175 2400 2435 2550 2695 2850 2695 - 3000 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 3375 2700 2700 --6 -6 2400 3075 3000 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 3335 2850 3075 2550 3075 2400 3335 2550 3595 2850 3595 - 3000 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 4200 2700 3600 --6 6 6750 4125 7050 4275 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6825 4200 20 20 6825 4200 6845 4200 @@ -37,4 +13,7 @@ 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6975 4200 20 20 6975 4200 6995 4200 -6 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 3300 300 300 5100 3300 5400 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 2400 300 300 2700 2400 3000 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 3300 300 300 2700 3300 3000 3300 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 3000 3900 3000 4500 @@ -53,7 +32,16 @@ 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 2400 3900 7200 3900 7200 4500 2400 4500 2400 3900 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 3300 2700 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 4200 5100 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 4200 2700 3600 +4 0 0 50 -1 5 14 0.0000 2 180 1800 3750 4800 [1000100...]\001 4 2 0 50 -1 0 12 0.0000 2 180 660 2100 4200 Array of\001 4 2 0 50 -1 0 12 0.0000 2 165 600 2100 4425 Queues\001 4 2 0 50 -1 0 12 0.0000 2 135 645 2100 3075 Threads\001 4 2 0 50 -1 0 12 0.0000 2 180 525 2100 2850 Ready\001 -4 0 0 50 -1 5 14 0.0000 2 180 1800 3750 4800 [1000100...]\001 Index: doc/theses/thierry_delisle_PhD/comp_II/img/emptytls.fig =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/img/emptytls.fig (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/img/emptytls.fig (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,35 +1,11 @@ -#FIG 3.2 Produced by xfig version 3.2.7a +#FIG 3.2 Produced by xfig version 3.2.5c Landscape Center Inches -Letter +Letter 100.00 Single -2 1200 2 -6 4800 3075 5400 4200 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 4200 5100 3600 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 3335 5250 3075 4950 3075 4800 3335 4950 3595 5250 3595 - 5400 3335 --6 -6 2400 2175 3000 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 2435 2850 2175 2550 2175 2400 2435 2550 2695 2850 2695 - 3000 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 3375 2700 2700 --6 -6 2400 3075 3000 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 3335 2850 3075 2550 3075 2400 3335 2550 3595 2850 3595 - 3000 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 4200 2700 3600 --6 6 6750 4125 7050 4275 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6825 4200 20 20 6825 4200 6845 4200 @@ -37,4 +13,7 @@ 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6975 4200 20 20 6975 4200 6995 4200 -6 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 3300 300 300 5100 3300 5400 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 2400 300 300 2700 2400 3000 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 3300 300 300 2700 3300 3000 3300 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 3000 3900 3000 4500 @@ -53,11 +32,20 @@ 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 2400 3900 7200 3900 7200 4500 2400 4500 2400 3900 -4 2 0 50 -1 0 12 0.0000 2 165 720 2100 4200 Array of\001 -4 2 0 50 -1 0 12 0.0000 2 150 540 2100 4425 Queues\001 -4 2 0 50 -1 0 12 0.0000 2 135 630 2100 3075 Threads\001 -4 2 0 50 -1 0 12 0.0000 2 165 450 2100 2850 Ready\001 -4 0 0 50 -1 5 14 0.0000 2 165 1080 2400 5100 [1000100...]\001 -4 0 0 50 -1 5 14 0.0000 2 165 1080 4425 5100 [1000100...]\001 -4 0 0 50 -1 5 14 0.0000 2 165 1080 6450 5100 [1000100...]\001 -4 0 0 50 -1 0 13 0.0000 2 135 630 1500 5175 Bitmask\001 -4 0 0 50 -1 0 13 0.0000 2 135 1080 1050 4950 Thread-Local\001 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 3300 2700 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 4200 5100 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 4200 2700 3600 +4 0 0 50 -1 5 14 0.0000 2 180 1800 2400 5100 [1000100...]\001 +4 0 0 50 -1 5 14 0.0000 2 180 1800 4425 5100 [1000100...]\001 +4 0 0 50 -1 5 14 0.0000 2 180 1800 6450 5100 [1000100...]\001 +4 0 0 50 -1 0 13 0.0000 2 135 690 1500 5175 Bitmask\001 +4 0 0 50 -1 0 13 0.0000 2 150 1155 1050 4950 Thread-Local\001 +4 2 0 50 -1 0 12 0.0000 2 180 660 2100 4200 Array of\001 +4 2 0 50 -1 0 12 0.0000 2 165 600 2100 4425 Queues\001 +4 2 0 50 -1 0 12 0.0000 2 135 645 2100 3075 Threads\001 +4 2 0 50 -1 0 12 0.0000 2 180 525 2100 2850 Ready\001 Index: doc/theses/thierry_delisle_PhD/comp_II/img/emptytree.fig =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/img/emptytree.fig (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/img/emptytree.fig (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -8,28 +8,4 @@ -2 1200 2 -6 4800 3075 5400 4200 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 4200 5100 3600 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 3335 5250 3075 4950 3075 4800 3335 4950 3595 5250 3595 - 5400 3335 --6 -6 2400 2175 3000 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 2435 2850 2175 2550 2175 2400 2435 2550 2695 2850 2695 - 3000 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 3375 2700 2700 --6 -6 2400 3075 3000 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 3335 2850 3075 2550 3075 2400 3335 2550 3595 2850 3595 - 3000 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 2700 4200 2700 3600 --6 6 6750 4125 7050 4275 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6825 4200 20 20 6825 4200 6845 4200 @@ -37,20 +13,7 @@ 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6975 4200 20 20 6975 4200 6995 4200 -6 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 3000 3900 3000 4500 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 3600 3900 3600 4500 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 4200 3900 4200 4500 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 4800 3900 4800 4500 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 5400 3900 5400 4500 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 6000 3900 6000 4500 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 - 6600 3900 6600 4500 -2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 - 2400 3900 7200 3900 7200 4500 2400 4500 2400 3900 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 3300 300 300 5100 3300 5400 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 2400 300 300 2700 2400 3000 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 3300 300 300 2700 3300 3000 3300 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 @@ -83,10 +46,35 @@ 1 1 1.00 45.00 90.00 5850 5400 6300 5100 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 3000 3900 3000 4500 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 3600 3900 3600 4500 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 4200 3900 4200 4500 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 4800 3900 4800 4500 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 5400 3900 5400 4500 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 6000 3900 6000 4500 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 + 6600 3900 6600 4500 +2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 + 2400 3900 7200 3900 7200 4500 2400 4500 2400 3900 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 3300 2700 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 4200 5100 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 4200 2700 3600 +4 1 0 50 -1 0 12 0.0000 2 135 135 3300 4725 X\001 +4 1 0 50 -1 0 12 0.0000 2 135 135 3900 5025 X\001 +4 1 0 50 -1 0 12 0.0000 2 135 135 5700 4725 X\001 +4 1 0 50 -1 0 12 0.0000 2 135 135 6300 5025 X\001 4 2 0 50 -1 0 12 0.0000 2 180 660 2100 4200 Array of\001 4 2 0 50 -1 0 12 0.0000 2 165 600 2100 4425 Queues\001 4 2 0 50 -1 0 12 0.0000 2 135 645 2100 3075 Threads\001 4 2 0 50 -1 0 12 0.0000 2 180 525 2100 2850 Ready\001 -4 1 0 50 -1 0 12 0.0000 2 135 135 3300 4725 X\001 -4 1 0 50 -1 0 12 0.0000 2 135 135 3900 5025 X\001 -4 1 0 50 -1 0 12 0.0000 2 135 135 5700 4725 X\001 -4 1 0 50 -1 0 12 0.0000 2 135 135 6300 5025 X\001 Index: doc/theses/thierry_delisle_PhD/comp_II/img/resize.fig =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/img/resize.fig (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/img/resize.fig (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,90 +1,19 @@ -#FIG 3.2 Produced by xfig version 3.2.7a +#FIG 3.2 Produced by xfig version 3.2.5c Landscape Center Inches -Letter +Letter 100.00 Single -2 1200 2 -6 2400 3075 3000 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 3335 2850 3075 2550 3075 2400 3335 2550 3595 2850 3595 - 3000 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 +6 7500 3675 8475 4500 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 1 2 1 1 1.00 45.00 90.00 - 2700 4200 2700 3600 --6 -6 2400 2175 3000 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 3000 2435 2850 2175 2550 2175 2400 2435 2550 2695 2850 2695 - 3000 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 1 1 1.00 45.00 90.00 - 2700 3375 2700 2700 --6 -6 3600 2175 4200 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 4200 2435 4050 2175 3750 2175 3600 2435 3750 2695 4050 2695 - 4200 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 3900 3375 3900 2700 --6 -6 3600 3075 4200 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 4200 3335 4050 3075 3750 3075 3600 3335 3750 3595 4050 3595 - 4200 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 3900 4200 3900 3600 --6 -6 4200 3075 4800 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 4800 3335 4650 3075 4350 3075 4200 3335 4350 3595 4650 3595 - 4800 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 4500 4200 4500 3600 --6 -6 4800 3075 5400 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 3335 5250 3075 4950 3075 4800 3335 4950 3595 5250 3595 - 5400 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 4200 5100 3600 --6 -6 4800 2175 5400 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 2435 5250 2175 4950 2175 4800 2435 4950 2695 5250 2695 - 5400 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 3375 5100 2700 --6 -6 4800 1275 5400 2475 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 5400 1535 5250 1275 4950 1275 4800 1535 4950 1795 5250 1795 - 5400 1535 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 5100 2475 5100 1800 --6 -6 6000 2175 6600 3375 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 6600 2435 6450 2175 6150 2175 6000 2435 6150 2695 6450 2695 - 6600 2435 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 6300 3375 6300 2700 --6 -6 6000 3075 6600 4200 -2 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7 - 6600 3335 6450 3075 6150 3075 6000 3335 6150 3595 6450 3595 - 6600 3335 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 - 1 1 1.00 45.00 90.00 - 6300 4200 6300 3600 + 7500 4200 7950 4200 +4 0 0 50 -1 0 12 0.0000 2 135 915 7500 3825 Grows with\001 +4 0 0 50 -1 0 12 0.0000 2 135 840 7500 4050 additional\001 +4 0 0 50 -1 0 12 0.0000 2 135 840 7500 4425 processors\001 -6 6 6750 4125 7050 4275 @@ -93,13 +22,19 @@ 1 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6975 4200 20 20 6975 4200 6995 4200 -6 -6 7500 3675 8475 4500 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 1 2 - 1 1 1.00 45.00 90.00 - 1 1 1.00 45.00 90.00 - 7500 4200 7950 4200 -4 0 0 50 -1 0 12 0.0000 2 135 900 7500 3825 Grows with\001 -4 0 0 50 -1 0 12 0.0000 2 135 900 7500 4050 additional\001 -4 0 0 50 -1 0 12 0.0000 2 120 900 7500 4425 processors\001 --6 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 3900 2400 300 300 3900 2400 4200 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 3900 3300 300 300 3900 3300 4200 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 1500 300 300 5100 1500 5400 1500 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 2400 300 300 5100 2400 5400 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 5100 3300 300 300 5100 3300 5400 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 6300 2400 300 300 6300 2400 6600 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 6300 3300 300 300 6300 3300 6600 3300 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 4509 3302 300 300 4509 3302 4809 3302 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 2400 300 300 2700 2400 3000 2400 +1 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 2700 3300 300 300 2700 3300 3000 3300 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 3 + 1 1 1.00 60.00 120.00 + 3750 5550 2400 5550 2400 4500 +2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 + 3600 5100 4500 5100 4500 6000 3600 6000 3600 5100 2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2 3000 3900 3000 4500 @@ -118,13 +53,38 @@ 2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 2400 3900 7200 3900 7200 4500 2400 4500 2400 3900 -2 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5 - 3600 5100 4500 5100 4500 6300 3600 6300 3600 5100 -2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 3 - 1 1 1.00 60.00 120.00 - 3750 5550 2400 5550 2400 4500 -4 2 0 50 -1 0 12 0.0000 2 165 720 2100 4200 Array of\001 -4 2 0 50 -1 0 12 0.0000 2 150 540 2100 4425 Queues\001 -4 2 0 50 -1 0 12 0.0000 2 135 630 2100 3075 Threads\001 -4 2 0 50 -1 0 12 0.0000 2 165 450 2100 2850 Ready\001 -4 0 0 50 -1 0 13 0.0000 2 135 1980 3600 5025 Cluster Data Strcuture\001 -4 0 0 50 -1 0 13 0.0000 2 165 1170 2400 5775 Array Pointer\001 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 3300 2700 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 3900 3300 3900 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 3900 4200 3900 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 2475 5100 1800 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 3300 5100 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 5100 4200 5100 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 6300 3300 6300 2700 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 6300 4200 6300 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 2700 4200 2700 3600 +2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2 + 1 1 1.00 45.00 90.00 + 4500 4200 4500 3600 +4 0 0 50 -1 0 13 0.0000 2 180 1170 2400 5775 Array Pointer\001 +4 2 0 50 -1 0 12 0.0000 2 180 660 2100 4200 Array of\001 +4 2 0 50 -1 0 12 0.0000 2 165 600 2100 4425 Queues\001 +4 2 0 50 -1 0 12 0.0000 2 135 645 2100 3075 Threads\001 +4 2 0 50 -1 0 12 0.0000 2 180 525 2100 2850 Ready\001 +4 1 0 50 -1 0 13 0.0000 2 150 1890 4050 5025 Cluster Data Structure\001 Index: doc/theses/thierry_delisle_PhD/comp_II/local.bib =================================================================== --- doc/theses/thierry_delisle_PhD/comp_II/local.bib (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ doc/theses/thierry_delisle_PhD/comp_II/local.bib (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -76,5 +76,5 @@ @article{finkel1987dib, - title={DIB—a distributed implementation of backtracking}, + title={DIB-a distributed implementation of backtracking}, author={Finkel, Raphael and Manber, Udi}, journal={ACM Transactions on Programming Languages and Systems (TOPLAS)}, @@ -223,6 +223,25 @@ % =============================================================================== -% MISC -% =============================================================================== +% Algorithms +% =============================================================================== +@article{michael2004hazard, + title={Hazard pointers: Safe memory reclamation for lock-free objects}, + author={Michael, Maged M}, + journal={IEEE Transactions on Parallel and Distributed Systems}, + volume={15}, + number={6}, + pages={491--504}, + year={2004}, + publisher={IEEE} +} + +@inproceedings{brown2015reclaiming, + title={Reclaiming memory for lock-free data structures: There has to be a better way}, + author={Brown, Trevor Alexander}, + booktitle={Proceedings of the 2015 ACM Symposium on Principles of Distributed Computing}, + pages={261--270}, + year={2015} +} + % Trevor's relaxed FIFO list @inproceedings{alistarh2018relaxed, @@ -242,2 +261,79 @@ year={2007} } + +% =============================================================================== +% Linux Man Pages +% =============================================================================== +@manual{open, + key = "open", + title = "open(2) Linux User's Manual", + year = "2020", + month = "February", +} + +@manual{epoll, + key = "epoll", + title = "epoll(7) Linux User's Manual", + year = "2019", + month = "March", +} + +@manual{select, + key = "select", + title = "select(7) Linux User's Manual", + year = "2019", + month = "March", +} + +@misc{io_uring, + title = {Efficient IO with io\_uring}, + author = {Axboe, Jens}, + year = "2019", + month = "March", + version = {0,4}, + howpublished = {\url{https://kernel.dk/io_uring.pdf}} +} + +@misc{libuv, + key = "libuv", + title = {libuv}, + howpublished = {\url{https://github.com/libuv/libuv}} +} + +% =============================================================================== +% MISC +% =============================================================================== + +@misc{nginx-design, + key = "nginx", + title={Inside {NGINX}: How We Designed for Performance \& Scale}, + howpublished= {\href{https://www.nginx.com/blog/inside-nginx-how-we-designed-for-performance-scale} + {https://\-www.nginx.com/\-blog/\-inside\--nginx\--how\--we\--designed\--for\--performance\--scale}}, +} + +@article{schillings1996engineering, + title={Be engineering insights: Benaphores}, + author={Schillings, Benoit}, + journal={Be Newsletters}, + volume={1}, + number={26}, + year={1996} +} + +@misc{wiki:thunderherd, + author = "{Wikipedia contributors}", + title = "Thundering herd problem --- {W}ikipedia{,} The Free Encyclopedia", + year = "2020", + howpublished = {\href{https://en.wikipedia.org/wiki/Thundering_herd_problem} + {https://\-en.wikipedia.org/\-wiki/\-Thundering\_herd\_problem}},}, + note = "[Online; accessed 14-April-2020]" +} + +@misc{wiki:ubuntu-linux, + author = "{Wikipedia contributors}", + title = "Ubuntu version history : Table of versions --- {W}ikipedia{,} The Free Encyclopedia", + year = "2020", + howpublished = {\href{https://en.wikipedia.org/wiki/Ubuntu_version_history\#Table_of_versions} + {https://\-en.wikipedia.org/\-wiki/\-Ubuntu\_version\_history\#Table\_of\_versions}}, + note = "[Online; accessed 15-April-2020]" +} Index: driver/cfa.cc =================================================================== --- driver/cfa.cc (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ driver/cfa.cc (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -385,9 +385,14 @@ } // if + string preludedir; switch(path) { - case Installed : Putenv( argv, "--prelude-dir=" + libdir ); break; - case BuildTree : Putenv( argv, "--prelude-dir=" + libdir + "/prelude" ); break; - case Distributed : Putenv( argv, "--prelude-dir=" + dir(argv[0]) ); break; + case Installed : preludedir = libdir; break; + case BuildTree : preludedir = libdir + "/prelude"; break; + case Distributed : preludedir = dir(argv[0]); break; } + + Putenv( argv, "--prelude-dir=" + preludedir ); + args[nargs++] = "-include"; + args[nargs++] = (*new string(preludedir + "/defines.hfa")).c_str(); for ( int i = 0; i < nlibs; i += 1 ) { // copy non-user libraries after all user libraries Index: examples/io/simple/server.cfa =================================================================== --- examples/io/simple/server.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ examples/io/simple/server.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,137 @@ +#include +#include +#include + +#include + +extern "C" { + #include + #include + #include +} + +#include +#include + +//---------- +monitor Printer {}; + +void heartbeat( Printer & mutex ) { + fprintf(stderr, "."); +} + +void message( Printer & mutex, char * msg, size_t len ) { + fprintf(stderr, "'%.*s'", len, msg); +} + +void status( Printer & mutex, const char * st ) { + fprintf(stderr, "%s\n", st); +} + +void error( Printer & mutex, const char * msg, int error) { + fprintf(stderr, "%s - %s\n", msg, strerror(error)); +} + +Printer printer; + +//---------- +thread HeartBeat {}; + +void ^?{}( HeartBeat & mutex ) {} + +void main( HeartBeat & this ) { + while(true) { + waitfor( ^?{} : this ) { break; } + or else{ + sleep( 5`s ); + heartbeat( printer ); + } + } +} + +//---------- +extern ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags); +extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags); +extern int cfa_close(int fd); + +//---------- +thread Server { int port; }; +void main( Server & this ) { + char data[256]; + struct iovec iov = { data, 256 }; + struct msghdr msg = { "", 0, &iov, 1, NULL, 0, 0 }; + + int sock = socket(AF_INET, SOCK_STREAM, 0); + if(sock < 0) { + error( printer, "socket", -sock); + exit( EXIT_FAILURE ); + } + + status( printer, "Socket created" ); + + struct sockaddr_in serv_addr; + memset(&serv_addr, 0, sizeof(serv_addr)); + serv_addr.sin_family = AF_INET; + serv_addr.sin_addr.s_addr = INADDR_ANY; + serv_addr.sin_port = htons(this.port); + + int ret = bind(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)); + if(ret < 0) { + error( printer, "bind", -ret); + exit( EXIT_FAILURE ); + } + + status( printer, "Socket bound" ); + + listen(sock,1); + + struct sockaddr_in cli_addr; + __socklen_t clilen = sizeof(cli_addr); + int newsock = cfa_accept4(sock, (struct sockaddr *) &cli_addr, &clilen, 0); + if (newsock < 0) { + error( printer, "accept", -newsock); + exit( EXIT_FAILURE ); + } + + status( printer, "Socket accepted, looping" ); + + while(1) { + int res = cfa_recvmsg(newsock, &msg, 0); + if(res == 0) break; + if(res < 0) { + error( printer, "recvmsg", -res); + exit( EXIT_FAILURE ); + } + + message(printer, data, res); + } + + ret = cfa_close(newsock); + if(ret < 0) { + error( printer, "close new", -ret); + exit( EXIT_FAILURE ); + } + + ret = cfa_close(sock); + if(ret < 0) { + error( printer, "close old", -ret); + exit( EXIT_FAILURE ); + } +} + +//---------- +int main(int argc, char * argv []) { + if(argc != 2) { + printf("usage: %s portnumber\n", argv[0]); + exit( EXIT_FAILURE ); + } + int port = atoi(argv[1]); + if(port < 1) { + printf("Invalid port : %d (from %s)\n", port, argv[1]); + exit( EXIT_FAILURE ); + } + + HeartBeat heartbeat; + Server server = { port }; + // while(true); +} Index: libcfa/Makefile.in =================================================================== --- libcfa/Makefile.in (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/Makefile.in (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -106,4 +106,5 @@ configure.lineno config.status.lineno mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/prelude/defines.hfa CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = Index: libcfa/configure =================================================================== --- libcfa/configure (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/configure (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -790,6 +790,6 @@ enable_distcc with_cfa_name +enable_static enable_shared -enable_static with_pic enable_fast_install @@ -1452,6 +1452,6 @@ --disable-silent-rules verbose build output (undo: "make V=0") --enable-distcc whether or not to enable distributed compilation + --enable-static[=PKGS] build static libraries [default=no] --enable-shared[=PKGS] build shared libraries [default=yes] - --enable-static[=PKGS] build static libraries [default=yes] --enable-fast-install[=PKGS] optimize for fast installation [default=yes] @@ -1960,4 +1960,95 @@ } # ac_fn_cxx_try_link + +# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists, giving a warning if it cannot be compiled using +# the include files in INCLUDES and setting the cache variable VAR +# accordingly. +ac_fn_c_check_header_mongrel () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if eval \${$3+:} false; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +else + # Is the header compilable? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 +$as_echo_n "checking $2 usability... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_header_compiler=yes +else + ac_header_compiler=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 +$as_echo "$ac_header_compiler" >&6; } + +# Is the header present? +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 +$as_echo_n "checking $2 presence... " >&6; } +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include <$2> +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + ac_header_preproc=yes +else + ac_header_preproc=no +fi +rm -f conftest.err conftest.i conftest.$ac_ext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 +$as_echo "$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( + yes:no: ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 +$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} + ;; + no:yes:* ) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 +$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 +$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 +$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 +$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 +$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} +( $as_echo "## --------------------------------------- ## +## Report this to cforall@plg.uwaterloo.ca ## +## --------------------------------------- ##" + ) | sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + eval "$3=\$ac_header_compiler" +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_header_mongrel cat >config.log <<_ACEOF This file contains any messages produced by compilers while @@ -7939,4 +8030,33 @@ # Set options +# Check whether --enable-static was given. +if test "${enable_static+set}" = set; then : + enableval=$enable_static; p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, + for pkg in $enableval; do + IFS=$lt_save_ifs + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS=$lt_save_ifs + ;; + esac +else + enable_static=no +fi + + + + + + + @@ -7971,34 +8091,4 @@ fi - - - - - - - - - # Check whether --enable-static was given. -if test "${enable_static+set}" = set; then : - enableval=$enable_static; p=${PACKAGE-default} - case $enableval in - yes) enable_static=yes ;; - no) enable_static=no ;; - *) - enable_static=no - # Look at the argument we got. We use all the common list separators. - lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, - for pkg in $enableval; do - IFS=$lt_save_ifs - if test "X$pkg" = "X$p"; then - enable_static=yes - fi - done - IFS=$lt_save_ifs - ;; - esac -else - enable_static=yes -fi @@ -16859,5 +16949,33 @@ +for ac_header in linux/io_uring.h +do : + ac_fn_c_check_header_mongrel "$LINENO" "linux/io_uring.h" "ac_cv_header_linux_io_uring_h" "$ac_includes_default" +if test "x$ac_cv_header_linux_io_uring_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_LINUX_IO_URING_H 1 +_ACEOF + +fi + +done + +for ac_func in preadv2 pwritev2 +do : + as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` +ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" +if eval test \"x\$"$as_ac_var"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 +_ACEOF + +fi +done + + ac_config_files="$ac_config_files Makefile src/Makefile prelude/Makefile" + + +ac_config_headers="$ac_config_headers prelude/defines.hfa" @@ -16952,41 +17070,5 @@ test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' -# Transform confdefs.h into DEFS. -# Protect against shell expansion while executing Makefile rules. -# Protect against Makefile macro expansion. -# -# If the first sed substitution is executed (which looks for macros that -# take arguments), then branch to the quote section. Otherwise, -# look for a macro that doesn't take arguments. -ac_script=' -:mline -/\\$/{ - N - s,\\\n,, - b mline -} -t clear -:clear -s/^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*([^)]*)\)[ ]*\(.*\)/-D\1=\2/g -t quote -s/^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)/-D\1=\2/g -t quote -b any -:quote -s/[ `~#$^&*(){}\\|;'\''"<>?]/\\&/g -s/\[/\\&/g -s/\]/\\&/g -s/\$/$$/g -H -:any -${ - g - s/^\n// - s/\n/ /g - p -} -' -DEFS=`sed -n "$ac_script" confdefs.h` - +DEFS=-DHAVE_CONFIG_H ac_libobjs= @@ -17466,4 +17548,7 @@ esac +case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$*;; +esac @@ -17471,4 +17556,5 @@ # Files that config.status was made for. config_files="$ac_config_files" +config_headers="$ac_config_headers" config_commands="$ac_config_commands" @@ -17492,7 +17578,12 @@ --file=FILE[:TEMPLATE] instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE Configuration files: $config_files + +Configuration headers: +$config_headers Configuration commands: @@ -17562,5 +17653,16 @@ as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; - --he | --h | --help | --hel | -h ) + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_HEADERS " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + as_fn_error $? "ambiguous option: \`$1' +Try \`$0 --help' for more information.";; + --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ @@ -17625,6 +17727,6 @@ macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' +enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' -enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' @@ -18009,4 +18111,5 @@ "src/Makefile") CONFIG_FILES="$CONFIG_FILES src/Makefile" ;; "prelude/Makefile") CONFIG_FILES="$CONFIG_FILES prelude/Makefile" ;; + "prelude/defines.hfa") CONFIG_HEADERS="$CONFIG_HEADERS prelude/defines.hfa" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; @@ -18021,4 +18124,5 @@ if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands fi @@ -18209,6 +18313,114 @@ fi # test -n "$CONFIG_FILES" - -eval set X " :F $CONFIG_FILES :C $CONFIG_COMMANDS" +# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +cat >"$ac_tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. + +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{148\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{148\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' >$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 +fi # test -n "$CONFIG_HEADERS" + + +eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" shift for ac_tag @@ -18429,5 +18641,62 @@ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; - + :H) + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +$as_echo "$as_me: $ac_file is unchanged" >&6;} + else + rm -f "$ac_file" + mv "$ac_tmp/config.h" "$ac_file" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + fi + else + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ + || as_fn_error $? "could not create -" "$LINENO" 5 + fi +# Compute "$ac_file"'s index in $config_headers. +_am_arg="$ac_file" +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + $_am_arg | $_am_arg:* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" || +$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$_am_arg" : 'X\(//\)[^/]' \| \ + X"$_am_arg" : 'X\(//\)$' \| \ + X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$_am_arg" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'`/stamp-h$_am_stamp_count + ;; :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 @@ -18587,9 +18856,9 @@ macro_revision=$macro_revision +# Whether or not to build static libraries. +build_old_libs=$enable_static + # Whether or not to build shared libraries. build_libtool_libs=$enable_shared - -# Whether or not to build static libraries. -build_old_libs=$enable_static # What type of objects to build. Index: libcfa/configure.ac =================================================================== --- libcfa/configure.ac (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/configure.ac (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -109,5 +109,5 @@ # Checks for programs. -LT_INIT +LT_INIT([disable-static]) AC_PROG_CXX @@ -118,4 +118,7 @@ AC_PROG_MAKE_SET +AC_CHECK_HEADERS([linux/io_uring.h]) +AC_CHECK_FUNCS([preadv2 pwritev2]) + AC_CONFIG_FILES([ Makefile @@ -124,4 +127,6 @@ ]) +AC_CONFIG_HEADERS(prelude/defines.hfa) + AC_OUTPUT() Index: libcfa/prelude/Makefile.am =================================================================== --- libcfa/prelude/Makefile.am (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/prelude/Makefile.am (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -21,5 +21,5 @@ # put into lib for now cfalibdir = ${CFA_LIBDIR} -cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c +cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c defines.hfa CC = @LOCAL_CFACC@ Index: libcfa/prelude/Makefile.in =================================================================== --- libcfa/prelude/Makefile.in (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/prelude/Makefile.in (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,6 +1,6 @@ -# Makefile.in generated by automake 1.16.1 from Makefile.am. +# Makefile.in generated by automake 1.15 from Makefile.am. # @configure_input@ -# Copyright (C) 1994-2018 Free Software Foundation, Inc. +# Copyright (C) 1994-2014 Free Software Foundation, Inc. # This Makefile.in is free software; the Free Software Foundation @@ -104,4 +104,5 @@ DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = defines.hfa CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = @@ -154,6 +155,25 @@ am__installdirs = "$(DESTDIR)$(cfalibdir)" DATA = $(cfalib_DATA) -am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -am__DIST_COMMON = $(srcdir)/Makefile.in +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \ + $(LISP)defines.hfa.in +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/defines.hfa.in DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ACLOCAL = @ACLOCAL@ @@ -306,10 +326,11 @@ # put into lib for now cfalibdir = ${CFA_LIBDIR} -cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c +cfalib_DATA = gcc-builtins.cf builtins.cf extras.cf prelude.cfa bootloader.c defines.hfa AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC @ARCH_FLAGS@ @CONFIG_CFLAGS@ AM_CFAFLAGS = @CONFIG_CFAFLAGS@ MOSTLYCLEANFILES = bootloader.c builtins.cf extras.cf gcc-builtins.c gcc-builtins.cf prelude.cfa MAINTAINERCLEANFILES = ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}} -all: all-am +all: defines.hfa + $(MAKE) $(AM_MAKEFLAGS) all-am .SUFFIXES: @@ -331,6 +352,6 @@ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ *) \ - echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ - cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ esac; @@ -343,4 +364,19 @@ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh $(am__aclocal_m4_deps): + +defines.hfa: stamp-h1 + @test -f $@ || rm -f stamp-h1 + @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1 + +stamp-h1: $(srcdir)/defines.hfa.in $(top_builddir)/config.status + @rm -f stamp-h1 + cd $(top_builddir) && $(SHELL) ./config.status prelude/defines.hfa +$(srcdir)/defines.hfa.in: $(am__configure_deps) + ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) + rm -f stamp-h1 + touch $@ + +distclean-hdr: + -rm -f defines.hfa stamp-h1 mostlyclean-libtool: @@ -370,15 +406,58 @@ files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ dir='$(DESTDIR)$(cfalibdir)'; $(am__uninstall_files_from_dir) -tags TAGS: - -ctags CTAGS: - -cscope cscopelist: - - -distdir: $(BUILT_SOURCES) - $(MAKE) $(AM_MAKEFLAGS) distdir-am - -distdir-am: $(DISTFILES) + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ @@ -412,5 +491,5 @@ check-am: all-am check: check-am -all-am: Makefile $(DATA) +all-am: Makefile $(DATA) defines.hfa installdirs: for dir in "$(DESTDIR)$(cfalibdir)"; do \ @@ -455,5 +534,5 @@ distclean: distclean-am -rm -f Makefile -distclean-am: clean-am distclean-generic +distclean-am: clean-am distclean-generic distclean-hdr distclean-tags dvi: dvi-am @@ -516,9 +595,10 @@ uninstall-am: uninstall-cfalibDATA -.MAKE: install-am install-strip - -.PHONY: all all-am check check-am clean clean-generic clean-libtool \ - cscopelist-am ctags-am distclean distclean-generic \ - distclean-libtool distdir dvi dvi-am html html-am info info-am \ +.MAKE: all install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ + clean-libtool cscopelist-am ctags ctags-am distclean \ + distclean-generic distclean-hdr distclean-libtool \ + distclean-tags distdir dvi dvi-am html html-am info info-am \ install install-am install-cfalibDATA install-data \ install-data-am install-dvi install-dvi-am install-exec \ @@ -529,5 +609,5 @@ maintainer-clean-generic maintainer-clean-local mostlyclean \ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ - tags-am uninstall uninstall-am uninstall-cfalibDATA + tags tags-am uninstall uninstall-am uninstall-cfalibDATA .PRECIOUS: Makefile Index: libcfa/prelude/defines.hfa.in =================================================================== --- libcfa/prelude/defines.hfa.in (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ libcfa/prelude/defines.hfa.in (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,21 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// defines.hfa.in -- +// +// Author : Thierry Delisle +// Created On : Thu Apr 30 15:23:00 2020 +// Last Modified By : +// Last Modified On : +// Update Count : +// + +#undef HAVE_LINUX_IO_URING_H + +#undef HAVE_PREADV2 +#undef HAVE_PWRITEV2 + +#undef __CFA_NO_STATISTICS__ Index: libcfa/src/Makefile.am =================================================================== --- libcfa/src/Makefile.am (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/Makefile.am (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -33,5 +33,5 @@ # The built sources must not depend on the installed headers AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@ -AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@ +AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -fexceptions -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@ AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@ CFACC = @CFACC@ @@ -39,5 +39,5 @@ #---------------------------------------------------------------------------------------------------------------- if BUILDLIB -headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa +headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa containers/list.hfa headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \ containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa @@ -48,5 +48,5 @@ thread_headers_nosrc = concurrency/invoke.h thread_headers = concurrency/coroutine.hfa concurrency/thread.hfa concurrency/kernel.hfa concurrency/monitor.hfa concurrency/mutex.hfa -thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/preemption.cfa ${thread_headers:.hfa=.cfa} +thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/io.cfa concurrency/preemption.cfa ${thread_headers:.hfa=.cfa} else headers = Index: libcfa/src/Makefile.in =================================================================== --- libcfa/src/Makefile.in (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/Makefile.in (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -105,4 +105,5 @@ $(am__nobase_cfa_include_HEADERS_DIST) $(am__DIST_COMMON) mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/prelude/defines.hfa CONFIG_CLEAN_FILES = CONFIG_CLEAN_VPATH_FILES = @@ -164,8 +165,8 @@ am__libcfathread_la_SOURCES_DIST = \ concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa \ - concurrency/invoke.c concurrency/preemption.cfa \ - concurrency/coroutine.cfa concurrency/thread.cfa \ - concurrency/kernel.cfa concurrency/monitor.cfa \ - concurrency/mutex.cfa + concurrency/invoke.c concurrency/io.cfa \ + concurrency/preemption.cfa concurrency/coroutine.cfa \ + concurrency/thread.cfa concurrency/kernel.cfa \ + concurrency/monitor.cfa concurrency/mutex.cfa @BUILDLIB_TRUE@am__objects_3 = concurrency/coroutine.lo \ @BUILDLIB_TRUE@ concurrency/thread.lo concurrency/kernel.lo \ @@ -174,5 +175,6 @@ @BUILDLIB_TRUE@ concurrency/CtxSwitch-@ARCHITECTURE@.lo \ @BUILDLIB_TRUE@ concurrency/alarm.lo concurrency/invoke.lo \ -@BUILDLIB_TRUE@ concurrency/preemption.lo $(am__objects_3) +@BUILDLIB_TRUE@ concurrency/io.lo concurrency/preemption.lo \ +@BUILDLIB_TRUE@ $(am__objects_3) am_libcfathread_la_OBJECTS = $(am__objects_4) libcfathread_la_OBJECTS = $(am_libcfathread_la_OBJECTS) @@ -193,5 +195,5 @@ am__v_at_0 = @ am__v_at_1 = -DEFAULT_INCLUDES = -I.@am__isrc@ +DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/prelude depcomp = $(SHELL) $(top_srcdir)/automake/depcomp am__depfiles_maybe = depfiles @@ -239,8 +241,8 @@ containers/vector.hfa bitmanip.hfa math.hfa gmp.hfa time_t.hfa \ bits/align.hfa bits/containers.hfa bits/defs.hfa \ - bits/debug.hfa bits/locks.hfa concurrency/coroutine.hfa \ - concurrency/thread.hfa concurrency/kernel.hfa \ - concurrency/monitor.hfa concurrency/mutex.hfa \ - concurrency/invoke.h + bits/debug.hfa bits/locks.hfa containers/list.hfa \ + concurrency/coroutine.hfa concurrency/thread.hfa \ + concurrency/kernel.hfa concurrency/monitor.hfa \ + concurrency/mutex.hfa concurrency/invoke.h HEADERS = $(nobase_cfa_include_HEADERS) am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) @@ -456,10 +458,10 @@ # The built sources must not depend on the installed headers AM_CFAFLAGS = -quiet -cfalib -I$(srcdir)/stdhdr $(if $(findstring ${gdbwaittarget}, ${@}), -XCFA --gdb) @CONFIG_CFAFLAGS@ -AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@ +AM_CFLAGS = -g -Wall -Wno-unused-function -fPIC -fexceptions -pthread @ARCH_FLAGS@ @CONFIG_CFLAGS@ AM_CCASFLAGS = -g -Wall -Wno-unused-function @ARCH_FLAGS@ @CONFIG_CFLAGS@ @BUILDLIB_FALSE@headers_nosrc = #---------------------------------------------------------------------------------------------------------------- -@BUILDLIB_TRUE@headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa +@BUILDLIB_TRUE@headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa containers/list.hfa @BUILDLIB_FALSE@headers = @BUILDLIB_TRUE@headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \ @@ -474,5 +476,5 @@ @BUILDLIB_FALSE@thread_headers = @BUILDLIB_TRUE@thread_headers = concurrency/coroutine.hfa concurrency/thread.hfa concurrency/kernel.hfa concurrency/monitor.hfa concurrency/mutex.hfa -@BUILDLIB_TRUE@thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/preemption.cfa ${thread_headers:.hfa=.cfa} +@BUILDLIB_TRUE@thread_libsrc = concurrency/CtxSwitch-@ARCHITECTURE@.S concurrency/alarm.cfa concurrency/invoke.c concurrency/io.cfa concurrency/preemption.cfa ${thread_headers:.hfa=.cfa} #---------------------------------------------------------------------------------------------------------------- @@ -608,4 +610,6 @@ concurrency/$(DEPDIR)/$(am__dirstamp) concurrency/invoke.lo: concurrency/$(am__dirstamp) \ + concurrency/$(DEPDIR)/$(am__dirstamp) +concurrency/io.lo: concurrency/$(am__dirstamp) \ concurrency/$(DEPDIR)/$(am__dirstamp) concurrency/preemption.lo: concurrency/$(am__dirstamp) \ Index: libcfa/src/bitmanip.hfa =================================================================== --- libcfa/src/bitmanip.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/bitmanip.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -11,6 +11,6 @@ // Created On : Sat Mar 14 18:12:27 2020 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Mar 16 14:28:46 2020 -// Update Count : 49 +// Last Modified On : Sun Apr 19 22:29:58 2020 +// Update Count : 121 // @@ -21,64 +21,129 @@ // Bits are numbered 1-N. -#include +//#include + +#define __bitsizeof( n ) (sizeof(n) * __CHAR_BIT__) static inline { - // Count leading 0 bits. - unsigned int cl0( unsigned char n ) { return n != 0 ? __builtin_clz( n ) - (sizeof(unsigned int) * __CHAR_BIT__ - sizeof(n) * __CHAR_BIT__) : sizeof(n) * __CHAR_BIT__; } - unsigned int cl0( unsigned short int n ) { return n != 0 ? __builtin_clz( n ) - (sizeof(unsigned int) * __CHAR_BIT__ - sizeof(n) * __CHAR_BIT__) : sizeof(n) * __CHAR_BIT__; } - unsigned int cl0( unsigned int n ) { return n != 0 ? __builtin_clz( n ) : sizeof(n) * __CHAR_BIT__; } - unsigned int cl0( unsigned long int n ) { return n != 0 ? __builtin_clzl( n ) : sizeof(n) * __CHAR_BIT__; } - unsigned int cl0( unsigned long long int n ) { return n != 0 ? __builtin_clzll( n ) : sizeof(n) * __CHAR_BIT__; } + // Count leading 0 bits. + unsigned int leading0s( unsigned char n ) { return n != 0 ? __builtin_clz( n ) - (__bitsizeof(unsigned int) - __bitsizeof(n)) : __bitsizeof(n); } + unsigned int leading0s( unsigned short int n ) { return n != 0 ? __builtin_clz( n ) - (__bitsizeof(unsigned int) - __bitsizeof(n)) : __bitsizeof(n); } + unsigned int leading0s( unsigned int n ) { return n != 0 ? __builtin_clz( n ) : __bitsizeof(n); } + unsigned int leading0s( unsigned long int n ) { return n != 0 ? __builtin_clzl( n ) : __bitsizeof(n); } + unsigned int leading0s( unsigned long long int n ) { return n != 0 ? __builtin_clzll( n ) : __bitsizeof(n); } - // Count trailing 0 bits. - unsigned int ct0( unsigned char n ) { return n != 0 ? __builtin_ctz( n ) : sizeof(n) * __CHAR_BIT__; } - unsigned int ct0( unsigned short int n ) { return n != 0 ? __builtin_ctz( n ) : sizeof(n) * __CHAR_BIT__; } - unsigned int ct0( unsigned int n ) { return n != 0 ? __builtin_ctz( n ) : sizeof(n) * __CHAR_BIT__; } - unsigned int ct0( unsigned long int n ) { return n != 0 ? __builtin_ctzl( n ) : sizeof(n) * __CHAR_BIT__; } - unsigned int ct0( unsigned long long int n ) { return n != 0 ? __builtin_ctzll( n ) : sizeof(n) * __CHAR_BIT__; } + // Count trailing 0 bits. + unsigned int trailing0s( unsigned char n ) { return n != 0 ? __builtin_ctz( n ) : __bitsizeof(n); } + unsigned int trailing0s( unsigned short int n ) { return n != 0 ? __builtin_ctz( n ) : __bitsizeof(n); } + unsigned int trailing0s( unsigned int n ) { return n != 0 ? __builtin_ctz( n ) : __bitsizeof(n); } + unsigned int trailing0s( unsigned long int n ) { return n != 0 ? __builtin_ctzl( n ) : __bitsizeof(n); } + unsigned int trailing0s( unsigned long long int n ) { return n != 0 ? __builtin_ctzll( n ) : __bitsizeof(n); } - // Count all 1 bits. - unsigned int ca1( unsigned char n ) { return __builtin_popcount( n ); } - unsigned int ca1( unsigned short int n ) { return __builtin_popcount( n ); } - unsigned int ca1( unsigned int n ) { return __builtin_popcount( n ); } - unsigned int ca1( unsigned long int n ) { return __builtin_popcountl( n ); } - unsigned int ca1( unsigned long long int n ) { return __builtin_popcountll( n ); } + // Count all 1 bits. + unsigned int all1s( unsigned char n ) { return __builtin_popcount( n ); } + unsigned int all1s( unsigned short int n ) { return __builtin_popcount( n ); } + unsigned int all1s( unsigned int n ) { return __builtin_popcount( n ); } + unsigned int all1s( unsigned long int n ) { return __builtin_popcountl( n ); } + unsigned int all1s( unsigned long long int n ) { return __builtin_popcountll( n ); } - // Count all 0 bits. - unsigned int ca0( unsigned char n ) { return sizeof(n) * __CHAR_BIT__ - __builtin_popcount( n ); } - unsigned int ca0( unsigned short int n ) { return sizeof(n) * __CHAR_BIT__ - __builtin_popcount( n ); } - unsigned int ca0( unsigned int n ) { return sizeof(n) * __CHAR_BIT__ - __builtin_popcount( n ); } - unsigned int ca0( unsigned long int n ) { return sizeof(n) * __CHAR_BIT__ - __builtin_popcountl( n ); } - unsigned int ca0( unsigned long long int n ) { return sizeof(n) * __CHAR_BIT__ - __builtin_popcountll( n ); } + // Count all 0 bits. + unsigned int all0s( unsigned char n ) { return __bitsizeof(n) - __builtin_popcount( n ); } + unsigned int all0s( unsigned short int n ) { return __bitsizeof(n) - __builtin_popcount( n ); } + unsigned int all0s( unsigned int n ) { return __bitsizeof(n) - __builtin_popcount( n ); } + unsigned int all0s( unsigned long int n ) { return __bitsizeof(n) - __builtin_popcountl( n ); } + unsigned int all0s( unsigned long long int n ) { return __bitsizeof(n) - __builtin_popcountll( n ); } - // Find least significiant set bit. (ffs) - unsigned int fls( unsigned int n ) { return __builtin_ffs( n ); } - unsigned int fls( unsigned long int n ) { return __builtin_ffsl( n ); } - unsigned int fls( unsigned long long int n ) { return __builtin_ffsll( n ); } + // Find least significiant zero bit. (ffs) + unsigned int low0( unsigned char n ) { return __builtin_ffs( (typeof(n))~n ); } + unsigned int low0( unsigned short int n ) { return __builtin_ffs( (typeof(n))~n ); } + unsigned int low0( unsigned int n ) { return __builtin_ffs( ~n ); } + unsigned int low0( unsigned long int n ) { return __builtin_ffsl( ~n ); } + unsigned int low0( unsigned long long int n ) { return __builtin_ffsll( ~n ); } - // Find most significiant set bit. - unsigned int fms( unsigned char n ) { return n != 0 ? sizeof(unsigned int) * __CHAR_BIT__ - __builtin_clz( n ) : 0; } - unsigned int fms( unsigned short int n ) { return n != 0 ? sizeof(unsigned int) * __CHAR_BIT__ - __builtin_clz( n ) : 0; } - unsigned int fms( unsigned int n ) { return n != 0 ? sizeof(n) * __CHAR_BIT__ - __builtin_clz( n ) : 0; } - unsigned int fms( unsigned long int n ) { return n != 0 ? sizeof(n) * __CHAR_BIT__ - __builtin_clzl( n ) : 0; } - unsigned int fms( unsigned long long int n ) { return n != 0 ? sizeof(n) * __CHAR_BIT__ - __builtin_clzll( n ) : 0; } + // Find least significiant one bit. + unsigned int low1( unsigned int n ) { return __builtin_ffs( n ); } + unsigned int low1( unsigned long int n ) { return __builtin_ffsl( n ); } + unsigned int low1( unsigned long long int n ) { return __builtin_ffsll( n ); } - // Check for power of 2 - bool pow2( unsigned long int value ) { - return (value & (value - 1)) == 0; // clears bits below value, rounding down to the next lower multiple of value - } // pow2 + // Find most significiant zero bit. + unsigned int high0( unsigned char n ) { return n == (typeof(n))-1 ? 0 : __bitsizeof(unsigned int) - __builtin_clz( (typeof(n))~n ); } + unsigned int high0( unsigned short int n ) { return n == (typeof(n))-1 ? 0 : __bitsizeof(unsigned int) - __builtin_clz( (typeof(n))~n ); } + unsigned int high0( unsigned int n ) { return n == -1 ? 0 : __bitsizeof(n) - __builtin_clz( ~n ); } + unsigned int high0( unsigned long int n ) { return n == -1 ? 0 : __bitsizeof(n) - __builtin_clzl( ~n ); } + unsigned int high0( unsigned long long int n ) { return n == -1 ? 0 : __bitsizeof(n) - __builtin_clzll( ~n ); } - // Returns value aligned at the floor of align. - unsigned long int floor( unsigned long int value, unsigned long int align ) { - assert( pow2( align ) ); - return value & -align; // clear bits above or equal to align, giving value % align - } // floor + // Find most significiant one bit. + unsigned int high1( unsigned char n ) { return n == 0 ? 0 : __bitsizeof(unsigned int) - __builtin_clz( n ); } + unsigned int high1( unsigned short int n ) { return n == 0 ? 0 : __bitsizeof(unsigned int) - __builtin_clz( n ); } + unsigned int high1( unsigned int n ) { return n == 0 ? 0 : __bitsizeof(n) - __builtin_clz( n ); } + unsigned int high1( unsigned long int n ) { return n == 0 ? 0 : __bitsizeof(n) - __builtin_clzl( n ); } + unsigned int high1( unsigned long long int n ) { return n == 0 ? 0 : __bitsizeof(n) - __builtin_clzll( n ); } - // Returns value aligned at the ceiling of align. - unsigned long int ceiling( unsigned long int value, unsigned long int align ) { - assert( pow2( align ) ); - return -floor( -value, align ); // negate, round down, negate is the same as round up - } // ceiling -} + // Check for power of 2, clears bits below n, rounding down to the next lower multiple of n. 0 is not a power of 2 + // but this computation returns true because of the two's complement, so it is a special case. + bool is_pow2( unsigned char n ) { return n == 0 ? false : (n & (n - 1)) == 0; } + bool is_pow2( unsigned short int n ) { return n == 0 ? false : (n & (n - 1)) == 0; } + bool is_pow2( unsigned int n ) { return n == 0 ? false : (n & (n - 1)) == 0; } + bool is_pow2( unsigned long int n ) { return n == 0 ? false : (n & (n - 1)) == 0; } + bool is_pow2( unsigned long long int n ) { return n == 0 ? false : (n & (n - 1)) == 0; } + + // Returns n aligned at the floor of align, clear bits above or equal to align, giving n % align. + signed char floor2( signed char n, char align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + unsigned char floor2( unsigned char n, unsigned char align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + short int floor2( short int n, short int align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + unsigned short int floor2( unsigned short int n, unsigned short int align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + int floor2( int n, int align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + unsigned int floor2( unsigned int n, unsigned int align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + long int floor2( long int n, long int align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + unsigned long int floor2( unsigned long int n, unsigned long int align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + long long int floor2( long long int n, long long int align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + unsigned long long int floor2( unsigned long long int n, unsigned long long int align ) { /*assert( is_pow2( align ) );*/ return n & -align; } + + // forall( otype T | { T ?&?( T, T ); T -?( T ); } ) + // T floor2( T n, T align ) { /* assert( is_pow2( align ) ); */ return n & -align; } + + signed char floor( signed char n, 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( otype T | { T ?/?( T, T ); T ?*?( T, T ); } ) + // T floor( T n, T align ) { return n / align * align; } + + // Returns n aligned at the ceiling of align, negate, round down, negate is the same as round up. + signed char ceiling2( signed char n, char align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + unsigned char ceiling2( unsigned char n, unsigned char align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + short int ceiling2( short int n, short int align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + unsigned short int ceiling2( unsigned short int n, unsigned short int align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + int ceiling2( int n, int align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + unsigned int ceiling2( unsigned int n, unsigned int align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + long int ceiling2( long int n, long int align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + unsigned long int ceiling2( unsigned long int n, unsigned long int align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + long long int ceiling2( long long int n, long long int align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + unsigned long long int ceiling2( unsigned long long int n, unsigned long long int align ) { /*assert( is_pow2( align ) );*/ return -floor2( -n, align ); } + + // forall( otype T | { T floor2( T, T ); T -?( T ); } ) + // T ceiling2( T n, T align ) { /* assert( is_pow2( align ) ); */ return -floor2( -n, align ); } + + signed char ceiling( signed char n, char align ) { return (n + (align - 1)) / align; } + unsigned char ceiling( unsigned char n, unsigned char align ) { return (n + (align - 1)) / align; } + short int ceiling( short int n, short int align ) { return (n + (align - 1)) / align; } + unsigned short int ceiling( unsigned short int n, unsigned short int align ) { return (n + (align - 1)) / align; } + int ceiling( int n, int align ) { return (n + (align - 1)) / align; } + unsigned int ceiling( unsigned int n, unsigned int align ) { return (n + (align - 1)) / align; } + long int ceiling( long int n, long int align ) { return (n + (align - 1)) / align; } + unsigned long int ceiling( unsigned long int n, unsigned long int align ) { return (n + (align - 1)) / align; } + long long int ceiling( long long int n, long long int align ) { return (n + (align - 1)) / align; } + unsigned long long int ceiling( unsigned long long int n, unsigned long long int align ) { return (n + (align - 1)) / align; } + + // forall( otype T | { void ?{}( T &, one_t ); T ?+?( T, T ); T ?-?( T, T ); T ?/?( T, T ); } ) + // T ceiling( T n, T align ) { return (n + (align - (T){1})) / align; } +} // distribution // Local Variables: // Index: libcfa/src/bits/debug.hfa =================================================================== --- libcfa/src/bits/debug.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/bits/debug.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -9,7 +9,7 @@ // Author : Thierry Delisle // Created On : Mon Nov 28 12:27:26 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Feb 4 12:29:21 2020 -// Update Count : 9 +// Last Modified By : Andrew Beach +// Last Modified On : Mon Apr 27 10:15:00 2020 +// Update Count : 10 // @@ -40,5 +40,4 @@ #endif #include - #include extern void __cfaabi_bits_write( int fd, const char buffer[], int len ); @@ -49,17 +48,26 @@ extern void __cfaabi_bits_print_vararg( int fd, const char fmt[], va_list arg ); extern void __cfaabi_bits_print_buffer( int fd, char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format(printf, 4, 5) )); + +#if defined(__CFA_DEBUG_PRINT__) \ + || defined(__CFA_DEBUG_PRINT_IO__) || defined(__CFA_DEBUG_PRINT_IO_CORE__) \ + || defined(__CFA_DEBUG_PRINT_MONITOR__) || defined(__CFA_DEBUG_PRINT_PREEMPTION__) \ + || defined(__CFA_DEBUG_PRINT_RUNTIME_CORE__) || defined(__CFA_DEBUG_PRINT_EXCEPTION__) + #include + #include +#endif #ifdef __cforall } #endif +// Deprecated: Use the versions with the new module names. #ifdef __CFA_DEBUG_PRINT__ #define __cfaabi_dbg_write( buffer, len ) __cfaabi_bits_write( STDERR_FILENO, buffer, len ) #define __cfaabi_dbg_acquire() __cfaabi_bits_acquire() #define __cfaabi_dbg_release() __cfaabi_bits_release() - #define __cfaabi_dbg_print_safe(...) __cfaabi_bits_print_safe (__VA_ARGS__) - #define __cfaabi_dbg_print_nolock(...) __cfaabi_bits_print_nolock (__VA_ARGS__) - #define __cfaabi_dbg_print_buffer(...) __cfaabi_bits_print_buffer (__VA_ARGS__) - #define __cfaabi_dbg_print_buffer_decl(...) char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( __dbg_text, __dbg_len ); - #define __cfaabi_dbg_print_buffer_local(...) __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_write( __dbg_text, __dbg_len ); + #define __cfaabi_dbg_print_safe(...) __cfaabi_bits_print_safe ( STDERR_FILENO, __VA_ARGS__ ) + #define __cfaabi_dbg_print_nolock(...) __cfaabi_bits_print_nolock ( STDERR_FILENO, __VA_ARGS__ ) + #define __cfaabi_dbg_print_buffer(...) __cfaabi_bits_print_buffer ( STDERR_FILENO, __VA_ARGS__ ) + #define __cfaabi_dbg_print_buffer_decl(...) char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( STDERR_FILENO, __dbg_text, __dbg_len ); + #define __cfaabi_dbg_print_buffer_local(...) __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_write( STDERR_FILENO, __dbg_text, __dbg_len ); #else #define __cfaabi_dbg_write(...) ((void)0) @@ -73,4 +81,62 @@ #endif +// Debug print functions and statements: +// Most are wrappers around the bits printing function but are not always used. +// If they are used depends if the group (first argument) is active or not. The group must be one +// defined belowe. The other arguments depend on the wrapped function. +#define __cfadbg_write(group, buffer, len) \ + __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_write(STDERR_FILENO, buffer, len)) +#define __cfadbg_acquire(group) \ + __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_acquire()) +#define __cfadbg_release(group) \ + __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_release()) +#define __cfadbg_print_safe(group, ...) \ + __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_print_safe(STDERR_FILENO, __VA_ARGS__)) +#define __cfadbg_print_nolock(group, ...) \ + __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_print_nolock(STDERR_FILENO, __VA_ARGS__)) +#define __cfadbg_print_buffer(group, ...) \ + __CFADBG_PRINT_GROUP_##group(__cfaabi_bits_print_buffer(STDERR_FILENO, __VA_ARGS__)) +#define __cfadbg_print_buffer_decl(group, ...) \ + __CFADBG_PRINT_GROUP_##group(char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( __dbg_text, __dbg_len )) +#define __cfadbg_print_buffer_local(group, ...) \ + __CFADBG_PRINT_GROUP_##group(__dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write(STDERR_FILENO, __dbg_text, __dbg_len)) + +// The debug print groups: +#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_IO__) +# define __CFADBG_PRINT_GROUP_io(...) __VA_ARGS__ +#else +# define __CFADBG_PRINT_GROUP_io(...) ((void)0) +#endif +#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_IO__) || defined(__CFA_DEBUG_PRINT_IO_CORE__) +# define __CFADBG_PRINT_GROUP_io_core(...) __VA_ARGS__ +#else +# define __CFADBG_PRINT_GROUP_io_core(...) ((void)0) +#endif +#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_MONITOR__) +# define __CFADBG_PRINT_GROUP_monitor(...) __VA_ARGS__ +#else +# define __CFADBG_PRINT_GROUP_monitor(...) ((void)0) +#endif +#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_PREEMPTION__) +# define __CFADBG_PRINT_GROUP_preemption(...) __VA_ARGS__ +#else +# define __CFADBG_PRINT_GROUP_preemption(...) ((void)0) +#endif +#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_RUNTIME_CORE__) +# define __CFADBG_PRINT_GROUP_runtime_core(...) __VA_ARGS__ +#else +# define __CFADBG_PRINT_GROUP_runtime_core(...) ((void)0) +#endif +#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_READY_QUEUE__) +# define __CFADBG_PRINT_GROUP_ready_queue(...) __VA_ARGS__ +#else +# define __CFADBG_PRINT_GROUP_ready_queue(...) ((void)0) +#endif +#if defined(__CFA_DEBUG_PRINT__) || defined(__CFA_DEBUG_PRINT_EXCEPTION__) +# define __CFADBG_PRINT_GROUP_exception(...) __VA_ARGS__ +#else +# define __CFADBG_PRINT_GROUP_exception(...) ((void)0) +#endif + // Local Variables: // // mode: c // Index: libcfa/src/bits/locks.hfa =================================================================== --- libcfa/src/bits/locks.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/bits/locks.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -112,40 +112,55 @@ #endif + extern "C" { + char * strerror(int); + } + #define CHECKED(x) { int err = x; if( err != 0 ) abort("KERNEL ERROR: Operation \"" #x "\" return error %d - %s\n", err, strerror(err)); } + struct __bin_sem_t { - bool signaled; pthread_mutex_t lock; pthread_cond_t cond; + int val; }; static inline void ?{}(__bin_sem_t & this) with( this ) { - signaled = false; - pthread_mutex_init(&lock, NULL); - pthread_cond_init (&cond, NULL); + // Create the mutex with error checking + pthread_mutexattr_t mattr; + pthread_mutexattr_init( &mattr ); + pthread_mutexattr_settype( &mattr, PTHREAD_MUTEX_ERRORCHECK_NP); + pthread_mutex_init(&lock, &mattr); + + pthread_cond_init (&cond, 0p); + val = 0; } static inline void ^?{}(__bin_sem_t & this) with( this ) { - pthread_mutex_destroy(&lock); - pthread_cond_destroy (&cond); + CHECKED( pthread_mutex_destroy(&lock) ); + CHECKED( pthread_cond_destroy (&cond) ); } static inline void wait(__bin_sem_t & this) with( this ) { verify(__cfaabi_dbg_in_kernel()); - pthread_mutex_lock(&lock); - if(!signaled) { // this must be a loop, not if! + CHECKED( pthread_mutex_lock(&lock) ); + while(val < 1) { pthread_cond_wait(&cond, &lock); } - signaled = false; - pthread_mutex_unlock(&lock); + val -= 1; + CHECKED( pthread_mutex_unlock(&lock) ); } static inline bool post(__bin_sem_t & this) with( this ) { - pthread_mutex_lock(&lock); - bool needs_signal = !signaled; - signaled = true; - pthread_mutex_unlock(&lock); + bool needs_signal = false; - if (needs_signal) pthread_cond_signal(&cond); + CHECKED( pthread_mutex_lock(&lock) ); + if(val < 1) { + val += 1; + pthread_cond_signal(&cond); + needs_signal = true; + } + CHECKED( pthread_mutex_unlock(&lock) ); return needs_signal; } + + #undef CHECKED #endif Index: libcfa/src/bits/signal.hfa =================================================================== --- libcfa/src/bits/signal.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/bits/signal.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -54,5 +54,5 @@ sig, handler, flags, errno, strerror( errno ) ); - _exit( EXIT_FAILURE ); + _Exit( EXIT_FAILURE ); } // if } Index: libcfa/src/concurrency/alarm.cfa =================================================================== --- libcfa/src/concurrency/alarm.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/concurrency/alarm.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -51,5 +51,4 @@ this.alarm = alarm; this.period = period; - next = 0; set = false; kernel_alarm = false; @@ -60,5 +59,4 @@ this.alarm = alarm; this.period = period; - next = 0; set = false; kernel_alarm = true; @@ -71,80 +69,30 @@ } -#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__)) -bool validate( alarm_list_t * this ) { - alarm_node_t ** it = &this->head; - while( (*it) ) { - it = &(*it)->next; +void insert( alarm_list_t * this, alarm_node_t * n ) { + alarm_node_t * it = & (*this)`first; + while( it && (n->alarm > it->alarm) ) { + it = & (*it)`next; + } + if ( it ) { + insert_before( *it, *n ); + } else { + insert_last(*this, *n); } - return it == this->tail; -} -#endif - -static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) { - verify( !n->next ); - if( p == this->tail ) { - this->tail = &n->next; - } - else { - n->next = *p; - } - *p = n; - - verify( validate( this ) ); -} - -void insert( alarm_list_t * this, alarm_node_t * n ) { - alarm_node_t ** it = &this->head; - while( (*it) && (n->alarm > (*it)->alarm) ) { - it = &(*it)->next; - } - - insert_at( this, n, it ); - - verify( validate( this ) ); + verify( validate( *this ) ); } alarm_node_t * pop( alarm_list_t * this ) { - alarm_node_t * head = this->head; + verify( validate( *this ) ); + alarm_node_t * head = & (*this)`first; if( head ) { - this->head = head->next; - if( !head->next ) { - this->tail = &this->head; - } - head->next = 0p; + remove(*head); } - verify( validate( this ) ); + verify( validate( *this ) ); return head; } -static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) { - verify( it ); - verify( (*it) == n ); - - (*it) = n->next; - if( !n-> next ) { - this->tail = it; - } - n->next = 0p; - - verify( validate( this ) ); -} - -static inline void remove( alarm_list_t * this, alarm_node_t * n ) { - alarm_node_t ** it = &this->head; - while( (*it) && (*it) != n ) { - it = &(*it)->next; - } - - verify( validate( this ) ); - - if( *it ) { remove_at( this, n, it ); } - - verify( validate( this ) ); -} - void register_self( alarm_node_t * this ) { - alarm_list_t * alarms = &event_kernel->alarms; + alarm_list_t & alarms = event_kernel->alarms; disable_interrupts(); @@ -152,9 +100,9 @@ { verify( validate( alarms ) ); - bool first = !alarms->head; + bool first = ! & alarms`first; - insert( alarms, this ); + insert( &alarms, this ); if( first ) { - __kernel_set_timer( alarms->head->alarm - __kernel_get_time() ); + __kernel_set_timer( alarms`first.alarm - __kernel_get_time() ); } } @@ -168,6 +116,6 @@ lock( event_kernel->lock __cfaabi_dbg_ctx2 ); { - verify( validate( &event_kernel->alarms ) ); - remove( &event_kernel->alarms, this ); + verify( validate( event_kernel->alarms ) ); + remove( *this ); } unlock( event_kernel->lock ); @@ -176,4 +124,19 @@ } +//============================================================================================= +// Utilities +//============================================================================================= + +void sleep( Duration duration ) { + alarm_node_t node = { active_thread(), __kernel_get_time() + duration, 0`s }; + + register_self( &node ); + park( __cfaabi_dbg_ctx ); + + /* paranoid */ verify( !node.set ); + /* paranoid */ verify( & node`next == 0p ); + /* paranoid */ verify( & node`prev == 0p ); +} + // Local Variables: // // mode: c // Index: libcfa/src/concurrency/alarm.hfa =================================================================== --- libcfa/src/concurrency/alarm.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/concurrency/alarm.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -23,4 +23,6 @@ #include "time.hfa" +#include + struct $thread; struct processor; @@ -40,5 +42,6 @@ Time alarm; // time when alarm goes off Duration period; // if > 0 => period of alarm - alarm_node_t * next; // intrusive link list field + + DLISTED_MGD_IMPL_IN(alarm_node_t) union { @@ -50,6 +53,5 @@ bool kernel_alarm :1; // true if this is not a user defined alarm }; - -typedef alarm_node_t ** __alarm_it_t; +DLISTED_MGD_IMPL_OUT(alarm_node_t) void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period ); @@ -57,13 +59,5 @@ void ^?{}( alarm_node_t & this ); -struct alarm_list_t { - alarm_node_t * head; - __alarm_it_t tail; -}; - -static inline void ?{}( alarm_list_t & this ) with( this ) { - head = 0; - tail = &head; -} +typedef dlist(alarm_node_t, alarm_node_t) alarm_list_t; void insert( alarm_list_t * this, alarm_node_t * n ); Index: libcfa/src/concurrency/io.cfa =================================================================== --- libcfa/src/concurrency/io.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ libcfa/src/concurrency/io.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1100 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// io.cfa -- +// +// Author : Thierry Delisle +// Created On : Thu Apr 23 17:31:00 2020 +// Last Modified By : +// Last Modified On : +// Update Count : +// + +// #define __CFA_DEBUG_PRINT_IO__ +// #define __CFA_DEBUG_PRINT_IO_CORE__ + +#include "kernel.hfa" + +#if !defined(HAVE_LINUX_IO_URING_H) + void __kernel_io_startup( cluster &, int, bool ) { + // Nothing to do without io_uring + } + + void __kernel_io_finish_start( cluster & ) { + // Nothing to do without io_uring + } + + void __kernel_io_prepare_stop( cluster & ) { + // Nothing to do without io_uring + } + + void __kernel_io_shutdown( cluster &, bool ) { + // Nothing to do without io_uring + } + +#else + extern "C" { + #define _GNU_SOURCE /* See feature_test_macros(7) */ + #include + #include + #include + #include + #include + #include + + #include + } + + #include "bits/signal.hfa" + #include "kernel_private.hfa" + #include "thread.hfa" + + uint32_t entries_per_cluster() { + return 256; + } + + static void * __io_poller_slow( void * arg ); + + // Weirdly, some systems that do support io_uring don't actually define these + #ifdef __alpha__ + /* + * alpha is the only exception, all other architectures + * have common numbers for new system calls. + */ + #ifndef __NR_io_uring_setup + #define __NR_io_uring_setup 535 + #endif + #ifndef __NR_io_uring_enter + #define __NR_io_uring_enter 536 + #endif + #ifndef __NR_io_uring_register + #define __NR_io_uring_register 537 + #endif + #else /* !__alpha__ */ + #ifndef __NR_io_uring_setup + #define __NR_io_uring_setup 425 + #endif + #ifndef __NR_io_uring_enter + #define __NR_io_uring_enter 426 + #endif + #ifndef __NR_io_uring_register + #define __NR_io_uring_register 427 + #endif + #endif + + // Fast poller user-thread + // Not using the "thread" keyword because we want to control + // more carefully when to start/stop it + struct __io_poller_fast { + struct __io_data * ring; + bool waiting; + $thread thrd; + }; + + void ?{}( __io_poller_fast & this, struct cluster & cltr ) { + this.ring = cltr.io; + this.waiting = true; + (this.thrd){ "Fast I/O Poller", cltr }; + } + void ^?{}( __io_poller_fast & mutex this ); + void main( __io_poller_fast & this ); + static inline $thread * get_thread( __io_poller_fast & this ) { return &this.thrd; } + void ^?{}( __io_poller_fast & mutex this ) {} + + struct __submition_data { + // Head and tail of the ring (associated with array) + volatile uint32_t * head; + volatile uint32_t * tail; + + // The actual kernel ring which uses head/tail + // indexes into the sqes arrays + uint32_t * array; + + // number of entries and mask to go with it + const uint32_t * num; + const uint32_t * mask; + + // Submission flags (Not sure what for) + uint32_t * flags; + + // number of sqes not submitted (whatever that means) + uint32_t * dropped; + + // Like head/tail but not seen by the kernel + volatile uint32_t alloc; + volatile uint32_t ready; + + __spinlock_t lock; + + // A buffer of sqes (not the actual ring) + struct io_uring_sqe * sqes; + + // The location and size of the mmaped area + void * ring_ptr; + size_t ring_sz; + + // Statistics + #if !defined(__CFA_NO_STATISTICS__) + struct { + struct { + volatile unsigned long long int val; + volatile unsigned long long int cnt; + volatile unsigned long long int block; + } submit_avg; + } stats; + #endif + }; + + struct __completion_data { + // Head and tail of the ring + volatile uint32_t * head; + volatile uint32_t * tail; + + // number of entries and mask to go with it + const uint32_t * mask; + const uint32_t * num; + + // number of cqes not submitted (whatever that means) + uint32_t * overflow; + + // the kernel ring + struct io_uring_cqe * cqes; + + // The location and size of the mmaped area + void * ring_ptr; + size_t ring_sz; + + // Statistics + #if !defined(__CFA_NO_STATISTICS__) + struct { + struct { + unsigned long long int val; + unsigned long long int slow_cnt; + unsigned long long int fast_cnt; + } completed_avg; + } stats; + #endif + }; + + struct __io_data { + struct __submition_data submit_q; + struct __completion_data completion_q; + uint32_t ring_flags; + int cltr_flags; + int fd; + semaphore submit; + volatile bool done; + struct { + struct { + void * stack; + pthread_t kthrd; + } slow; + __io_poller_fast fast; + __bin_sem_t sem; + } poller; + }; + +//============================================================================================= +// I/O Startup / Shutdown logic +//============================================================================================= + void __kernel_io_startup( cluster & this, int io_flags, bool main_cluster ) { + this.io = malloc(); + + // Step 1 : call to setup + struct io_uring_params params; + memset(¶ms, 0, sizeof(params)); + + uint32_t nentries = entries_per_cluster(); + + int fd = syscall(__NR_io_uring_setup, nentries, ¶ms ); + if(fd < 0) { + abort("KERNEL ERROR: IO_URING SETUP - %s\n", strerror(errno)); + } + + // Step 2 : mmap result + memset( this.io, 0, sizeof(struct __io_data) ); + struct __submition_data & sq = this.io->submit_q; + struct __completion_data & cq = this.io->completion_q; + + // calculate the right ring size + sq.ring_sz = params.sq_off.array + (params.sq_entries * sizeof(unsigned) ); + cq.ring_sz = params.cq_off.cqes + (params.cq_entries * sizeof(struct io_uring_cqe)); + + // Requires features + #if defined(IORING_FEAT_SINGLE_MMAP) + // adjust the size according to the parameters + if ((params.features & IORING_FEAT_SINGLE_MMAP) != 0) { + cq->ring_sz = sq->ring_sz = max(cq->ring_sz, sq->ring_sz); + } + #endif + + // mmap the Submit Queue into existence + sq.ring_ptr = mmap(0, sq.ring_sz, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, fd, IORING_OFF_SQ_RING); + if (sq.ring_ptr == (void*)MAP_FAILED) { + abort("KERNEL ERROR: IO_URING MMAP1 - %s\n", strerror(errno)); + } + + // Requires features + #if defined(IORING_FEAT_SINGLE_MMAP) + // mmap the Completion Queue into existence (may or may not be needed) + if ((params.features & IORING_FEAT_SINGLE_MMAP) != 0) { + cq->ring_ptr = sq->ring_ptr; + } + else + #endif + { + // We need multiple call to MMAP + cq.ring_ptr = mmap(0, cq.ring_sz, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, fd, IORING_OFF_CQ_RING); + if (cq.ring_ptr == (void*)MAP_FAILED) { + munmap(sq.ring_ptr, sq.ring_sz); + abort("KERNEL ERROR: IO_URING MMAP2 - %s\n", strerror(errno)); + } + } + + // mmap the submit queue entries + size_t size = params.sq_entries * sizeof(struct io_uring_sqe); + sq.sqes = (struct io_uring_sqe *)mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, fd, IORING_OFF_SQES); + if (sq.sqes == (struct io_uring_sqe *)MAP_FAILED) { + munmap(sq.ring_ptr, sq.ring_sz); + if (cq.ring_ptr != sq.ring_ptr) munmap(cq.ring_ptr, cq.ring_sz); + abort("KERNEL ERROR: IO_URING MMAP3 - %s\n", strerror(errno)); + } + + // Get the pointers from the kernel to fill the structure + // submit queue + sq.head = (volatile uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.head); + sq.tail = (volatile uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.tail); + sq.mask = ( const uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.ring_mask); + sq.num = ( const uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.ring_entries); + sq.flags = ( uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.flags); + sq.dropped = ( uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.dropped); + sq.array = ( uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.array); + sq.alloc = *sq.tail; + sq.ready = *sq.tail; + + // completion queue + cq.head = (volatile uint32_t *)(((intptr_t)cq.ring_ptr) + params.cq_off.head); + cq.tail = (volatile uint32_t *)(((intptr_t)cq.ring_ptr) + params.cq_off.tail); + cq.mask = ( const uint32_t *)(((intptr_t)cq.ring_ptr) + params.cq_off.ring_mask); + cq.num = ( const uint32_t *)(((intptr_t)cq.ring_ptr) + params.cq_off.ring_entries); + cq.overflow = ( uint32_t *)(((intptr_t)cq.ring_ptr) + params.cq_off.overflow); + cq.cqes = (struct io_uring_cqe *)(((intptr_t)cq.ring_ptr) + params.cq_off.cqes); + + // some paranoid checks + /* paranoid */ verifyf( (*cq.mask) == ((*cq.num) - 1ul32), "IO_URING Expected mask to be %u (%u entries), was %u", (*cq.num) - 1ul32, *cq.num, *cq.mask ); + /* paranoid */ verifyf( (*cq.num) >= nentries, "IO_URING Expected %u entries, got %u", nentries, *cq.num ); + /* paranoid */ verifyf( (*cq.head) == 0, "IO_URING Expected head to be 0, got %u", *cq.head ); + /* paranoid */ verifyf( (*cq.tail) == 0, "IO_URING Expected tail to be 0, got %u", *cq.tail ); + + /* paranoid */ verifyf( (*sq.mask) == ((*sq.num) - 1ul32), "IO_URING Expected mask to be %u (%u entries), was %u", (*sq.num) - 1ul32, *sq.num, *sq.mask ); + /* paranoid */ verifyf( (*sq.num) >= nentries, "IO_URING Expected %u entries, got %u", nentries, *sq.num ); + /* paranoid */ verifyf( (*sq.head) == 0, "IO_URING Expected head to be 0, got %u", *sq.head ); + /* paranoid */ verifyf( (*sq.tail) == 0, "IO_URING Expected tail to be 0, got %u", *sq.tail ); + + // Update the global ring info + this.io->ring_flags = params.flags; + this.io->cltr_flags = io_flags; + this.io->fd = fd; + this.io->done = false; + (this.io->submit){ min(*sq.num, *cq.num) }; + + // Initialize statistics + #if !defined(__CFA_NO_STATISTICS__) + this.io->submit_q.stats.submit_avg.val = 0; + this.io->submit_q.stats.submit_avg.cnt = 0; + this.io->submit_q.stats.submit_avg.block = 0; + this.io->completion_q.stats.completed_avg.val = 0; + this.io->completion_q.stats.completed_avg.slow_cnt = 0; + this.io->completion_q.stats.completed_avg.fast_cnt = 0; + #endif + + if(!main_cluster) { + __kernel_io_finish_start( this ); + } + } + + void __kernel_io_finish_start( cluster & this ) { + if( this.io->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) { + __cfadbg_print_safe(io_core, "Kernel I/O : Creating fast poller for cluter %p\n", &this); + (this.io->poller.fast){ this }; + __thrd_start( this.io->poller.fast, main ); + } + + // Create the poller thread + __cfadbg_print_safe(io_core, "Kernel I/O : Creating slow poller for cluter %p\n", &this); + this.io->poller.slow.stack = __create_pthread( &this.io->poller.slow.kthrd, __io_poller_slow, &this ); + } + + void __kernel_io_prepare_stop( cluster & this ) { + __cfadbg_print_safe(io_core, "Kernel I/O : Stopping pollers for cluster\n", &this); + // Notify the poller thread of the shutdown + __atomic_store_n(&this.io->done, true, __ATOMIC_SEQ_CST); + + // Stop the IO Poller + sigval val = { 1 }; + pthread_sigqueue( this.io->poller.slow.kthrd, SIGUSR1, val ); + post( this.io->poller.sem ); + + // Wait for the poller thread to finish + pthread_join( this.io->poller.slow.kthrd, 0p ); + free( this.io->poller.slow.stack ); + + __cfadbg_print_safe(io_core, "Kernel I/O : Slow poller stopped for cluster\n", &this); + + if( this.io->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) { + with( this.io->poller.fast ) { + /* paranoid */ verify( waiting ); // The thread shouldn't be in a system call + /* paranoid */ verify( this.procs.head == 0p || &this == mainCluster ); + /* paranoid */ verify( this.idles.head == 0p || &this == mainCluster ); + + // We need to adjust the clean-up based on where the thread is + if( thrd.preempted != __NO_PREEMPTION ) { + + // This is the tricky case + // The thread was preempted and now it is on the ready queue + /* paranoid */ verify( thrd.state == Active ); // The thread better be in this state + /* paranoid */ verify( thrd.next == 1p ); // The thread should be the last on the list + /* paranoid */ verify( this.ready_queue.head == &thrd ); // The thread should be the only thing on the list + + // Remove the thread from the ready queue of this cluster + this.ready_queue.head = 1p; + thrd.next = 0p; + + // Fixup the thread state + thrd.state = Blocked; + thrd.preempted = __NO_PREEMPTION; + + // Pretend like the thread was blocked all along + } + // !!! This is not an else if !!! + if( thrd.state == Blocked ) { + + // This is the "easy case" + // The thread is parked and can easily be moved to active cluster + verify( thrd.curr_cluster != active_cluster() || thrd.curr_cluster == mainCluster ); + thrd.curr_cluster = active_cluster(); + + // unpark the fast io_poller + unpark( &thrd __cfaabi_dbg_ctx2 ); + } + else { + + // The thread is in a weird state + // I don't know what to do here + abort("Fast poller thread is in unexpected state, cannot clean-up correctly\n"); + } + + } + + ^(this.io->poller.fast){}; + + __cfadbg_print_safe(io_core, "Kernel I/O : Fast poller stopped for cluster\n", &this); + } + } + + void __kernel_io_shutdown( cluster & this, bool main_cluster ) { + if(!main_cluster) { + __kernel_io_prepare_stop( this ); + } + + // print statistics + #if !defined(__CFA_NO_STATISTICS__) + if(this.print_stats) { + with(this.io->submit_q.stats, this.io->completion_q.stats) { + __cfaabi_bits_print_safe( STDERR_FILENO, + "----- I/O uRing Stats -----\n" + "- total submit calls : %'15llu\n" + "- avg submit : %'18.2lf\n" + "- pre-submit block %% : %'18.2lf\n" + "- total wait calls : %'15llu (%'llu slow, %'llu fast)\n" + "- avg completion/wait : %'18.2lf\n", + submit_avg.cnt, + ((double)submit_avg.val) / submit_avg.cnt, + (100.0 * submit_avg.block) / submit_avg.cnt, + completed_avg.slow_cnt + completed_avg.fast_cnt, + completed_avg.slow_cnt, completed_avg.fast_cnt, + ((double)completed_avg.val) / (completed_avg.slow_cnt + completed_avg.fast_cnt) + ); + } + } + #endif + + // Shutdown the io rings + struct __submition_data & sq = this.io->submit_q; + struct __completion_data & cq = this.io->completion_q; + + // unmap the submit queue entries + munmap(sq.sqes, (*sq.num) * sizeof(struct io_uring_sqe)); + + // unmap the Submit Queue ring + munmap(sq.ring_ptr, sq.ring_sz); + + // unmap the Completion Queue ring, if it is different + if (cq.ring_ptr != sq.ring_ptr) { + munmap(cq.ring_ptr, cq.ring_sz); + } + + // close the file descriptor + close(this.io->fd); + + free( this.io ); + } + +//============================================================================================= +// I/O Polling +//============================================================================================= + struct io_user_data { + int32_t result; + $thread * thrd; + }; + + // Process a single completion message from the io_uring + // This is NOT thread-safe + static int __drain_io( struct __io_data & ring, sigset_t * mask, int waitcnt, bool in_kernel ) { + int ret = syscall( __NR_io_uring_enter, ring.fd, 0, waitcnt, IORING_ENTER_GETEVENTS, mask, _NSIG / 8); + if( ret < 0 ) { + switch((int)errno) { + case EAGAIN: + case EINTR: + return -EAGAIN; + default: + abort( "KERNEL ERROR: IO_URING WAIT - %s\n", strerror(errno) ); + } + } + + // Drain the queue + unsigned head = *ring.completion_q.head; + unsigned tail = __atomic_load_n(ring.completion_q.tail, __ATOMIC_ACQUIRE); + + // Nothing was new return 0 + if (head == tail) { + return 0; + } + + uint32_t count = tail - head; + for(i; count) { + unsigned idx = (head + i) & (*ring.completion_q.mask); + struct io_uring_cqe & cqe = ring.completion_q.cqes[idx]; + + /* paranoid */ verify(&cqe); + + struct io_user_data * data = (struct io_user_data *)cqe.user_data; + __cfadbg_print_safe( io, "Kernel I/O : Performed reading io cqe %p, result %d for %p\n", data, cqe.res, data->thrd ); + + data->result = cqe.res; + if(!in_kernel) { unpark( data->thrd __cfaabi_dbg_ctx2 ); } + else { __unpark( data->thrd __cfaabi_dbg_ctx2 ); } + } + + // Allow new submissions to happen + V(ring.submit, count); + + // Mark to the kernel that the cqe has been seen + // Ensure that the kernel only sees the new value of the head index after the CQEs have been read. + __atomic_fetch_add( ring.completion_q.head, count, __ATOMIC_RELAXED ); + + return count; + } + + static void * __io_poller_slow( void * arg ) { + cluster * cltr = (cluster *)arg; + struct __io_data & ring = *cltr->io; + + sigset_t mask; + sigfillset(&mask); + if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) { + abort( "KERNEL ERROR: IO_URING - pthread_sigmask" ); + } + + sigdelset( &mask, SIGUSR1 ); + + verify( (*ring.submit_q.head) == (*ring.submit_q.tail) ); + verify( (*ring.completion_q.head) == (*ring.completion_q.tail) ); + + __cfadbg_print_safe(io_core, "Kernel I/O : Slow poller for ring %p ready\n", &ring); + + if( ring.cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) { + while(!__atomic_load_n(&ring.done, __ATOMIC_SEQ_CST)) { + // In the user-thread approach drain and if anything was drained, + // batton pass to the user-thread + int count = __drain_io( ring, &mask, 1, true ); + + // Update statistics + #if !defined(__CFA_NO_STATISTICS__) + ring.completion_q.stats.completed_avg.val += count; + ring.completion_q.stats.completed_avg.slow_cnt += 1; + #endif + + if(count > 0) { + __cfadbg_print_safe(io_core, "Kernel I/O : Moving to ring %p to fast poller\n", &ring); + __unpark( &ring.poller.fast.thrd __cfaabi_dbg_ctx2 ); + wait( ring.poller.sem ); + } + } + } + else { + while(!__atomic_load_n(&ring.done, __ATOMIC_SEQ_CST)) { + //In the naive approach, just poll the io completion queue directly + int count = __drain_io( ring, &mask, 1, true ); + + // Update statistics + #if !defined(__CFA_NO_STATISTICS__) + ring.completion_q.stats.completed_avg.val += count; + ring.completion_q.stats.completed_avg.slow_cnt += 1; + #endif + } + } + + __cfadbg_print_safe(io_core, "Kernel I/O : Slow poller for ring %p stopping\n", &ring); + + return 0p; + } + + void main( __io_poller_fast & this ) { + verify( this.ring->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ); + + // Start parked + park( __cfaabi_dbg_ctx ); + + __cfadbg_print_safe(io_core, "Kernel I/O : Fast poller for ring %p ready\n", &this.ring); + + int reset = 0; + + // Then loop until we need to start + while(!__atomic_load_n(&this.ring->done, __ATOMIC_SEQ_CST)) { + // Drain the io + this.waiting = false; + int count = __drain_io( *this.ring, 0p, 0, false ); + reset += count > 0 ? 1 : 0; + + // Update statistics + #if !defined(__CFA_NO_STATISTICS__) + this.ring->completion_q.stats.completed_avg.val += count; + this.ring->completion_q.stats.completed_avg.fast_cnt += 1; + #endif + + this.waiting = true; + if(reset < 5) { + // If we got something, just yield and check again + yield(); + } + else { + // We didn't get anything baton pass to the slow poller + __cfadbg_print_safe(io_core, "Kernel I/O : Moving to ring %p to slow poller\n", &this.ring); + post( this.ring->poller.sem ); + park( __cfaabi_dbg_ctx ); + reset = 0; + } + } + + __cfadbg_print_safe(io_core, "Kernel I/O : Fast poller for ring %p stopping\n", &this.ring); + } + +//============================================================================================= +// I/O Submissions +//============================================================================================= + +// Submition steps : +// 1 - We need to make sure we don't overflow any of the buffer, P(ring.submit) to make sure +// entries are available. The semaphore make sure that there is no more operations in +// progress then the number of entries in the buffer. This probably limits concurrency +// more than necessary since submitted but not completed operations don't need any +// entries in user space. However, I don't know what happens if we overflow the buffers +// because too many requests completed at once. This is a safe approach in all cases. +// Furthermore, with hundreds of entries, this may be okay. +// +// 2 - Allocate a queue entry. The ring already has memory for all entries but only the ones +// listed in sq.array are visible by the kernel. For those not listed, the kernel does not +// offer any assurance that an entry is not being filled by multiple flags. Therefore, we +// need to write an allocator that allows allocating concurrently. +// +// 3 - Actually fill the submit entry, this is the only simple and straightforward step. +// +// 4 - Append the entry index to the array and adjust the tail accordingly. This operation +// needs to arrive to two concensus at the same time: +// A - The order in which entries are listed in the array: no two threads must pick the +// same index for their entries +// B - When can the tail be update for the kernel. EVERY entries in the array between +// head and tail must be fully filled and shouldn't ever be touched again. +// + + static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct __io_data & ring ) { + // Wait for a spot to be available + __attribute__((unused)) bool blocked = P(ring.submit); + #if !defined(__CFA_NO_STATISTICS__) + __atomic_fetch_add( &ring.submit_q.stats.submit_avg.block, blocked ? 1ul64 : 0ul64, __ATOMIC_RELAXED ); + #endif + + // Allocate the sqe + uint32_t idx = __atomic_fetch_add(&ring.submit_q.alloc, 1ul32, __ATOMIC_SEQ_CST); + + // Validate that we didn't overflow anything + // Check that nothing overflowed + /* paranoid */ verify( true ); + + // Check that it goes head -> tail -> alloc and never head -> alloc -> tail + /* paranoid */ verify( true ); + + // Return the sqe + return [&ring.submit_q.sqes[ idx & (*ring.submit_q.mask)], idx]; + } + + static inline void __submit( struct __io_data & ring, uint32_t idx ) { + // get mutual exclusion + lock(ring.submit_q.lock __cfaabi_dbg_ctx2); + + // Append to the list of ready entries + uint32_t * tail = ring.submit_q.tail; + const uint32_t mask = *ring.submit_q.mask; + + ring.submit_q.array[ (*tail) & mask ] = idx & mask; + __atomic_fetch_add(tail, 1ul32, __ATOMIC_SEQ_CST); + + // Submit however, many entries need to be submitted + int ret = syscall( __NR_io_uring_enter, ring.fd, 1, 0, 0, 0p, 0); + if( ret < 0 ) { + switch((int)errno) { + default: + abort( "KERNEL ERROR: IO_URING SUBMIT - %s\n", strerror(errno) ); + } + } + + // update statistics + #if !defined(__CFA_NO_STATISTICS__) + ring.submit_q.stats.submit_avg.val += 1; + ring.submit_q.stats.submit_avg.cnt += 1; + #endif + + unlock(ring.submit_q.lock); + // Make sure that idx was submitted + // Be careful to not get false positive if we cycled the entire list or that someone else submitted for us + __cfadbg_print_safe( io, "Kernel I/O : Performed io_submit for %p, returned %d\n", active_thread(), ret ); + } + + static inline void ?{}(struct io_uring_sqe & this, uint8_t opcode, int fd) { + this.opcode = opcode; + #if !defined(IOSQE_ASYNC) + this.flags = 0; + #else + this.flags = IOSQE_ASYNC; + #endif + this.ioprio = 0; + this.fd = fd; + this.off = 0; + this.addr = 0; + this.len = 0; + this.rw_flags = 0; + this.__pad2[0] = this.__pad2[1] = this.__pad2[2] = 0; + } + + static inline void ?{}(struct io_uring_sqe & this, uint8_t opcode, int fd, void * addr, uint32_t len, uint64_t off ) { + (this){ opcode, fd }; + this.off = off; + this.addr = (uint64_t)addr; + this.len = len; + } + + +//============================================================================================= +// I/O Interface +//============================================================================================= + + #define __submit_prelude \ + struct __io_data & ring = *active_cluster()->io; \ + struct io_uring_sqe * sqe; \ + uint32_t idx; \ + [sqe, idx] = __submit_alloc( ring ); + + #define __submit_wait \ + io_user_data data = { 0, active_thread() }; \ + /*__cfaabi_bits_print_safe( STDERR_FILENO, "Preparing user data %p for %p\n", &data, data.thrd );*/ \ + sqe->user_data = (uint64_t)&data; \ + __submit( ring, idx ); \ + park( __cfaabi_dbg_ctx ); \ + return data.result; +#endif + +// Some forward declarations +extern "C" { + #include + #include + #include + #include + +#if defined(HAVE_PREADV2) + struct iovec; + extern ssize_t preadv2 (int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags); +#endif +#if defined(HAVE_PWRITEV2) + struct iovec; + extern ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags); +#endif + + extern int fsync(int fd); + extern int sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags); + + struct msghdr; + struct sockaddr; + extern ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags); + extern ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags); + extern ssize_t send(int sockfd, const void *buf, size_t len, int flags); + extern ssize_t recv(int sockfd, void *buf, size_t len, int flags); + extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags); + extern int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen); + + extern int fallocate(int fd, int mode, uint64_t offset, uint64_t len); + extern int posix_fadvise(int fd, uint64_t offset, uint64_t len, int advice); + extern int madvise(void *addr, size_t length, int advice); + + extern int openat(int dirfd, const char *pathname, int flags, mode_t mode); + extern int close(int fd); + + extern ssize_t read (int fd, void *buf, size_t count); +} + +//----------------------------------------------------------------------------- +// Asynchronous operations +#if defined(HAVE_PREADV2) + ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_READV) + return preadv2(fd, iov, iovcnt, offset, flags); + #else + __submit_prelude + + (*sqe){ IORING_OP_READV, fd, iov, iovcnt, offset }; + + __submit_wait + #endif + } +#endif + +#if defined(HAVE_PWRITEV2) + ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_WRITEV) + return pwritev2(fd, iov, iovcnt, offset, flags); + #else + __submit_prelude + + (*sqe){ IORING_OP_WRITEV, fd, iov, iovcnt, offset }; + + __submit_wait + #endif + } +#endif + +int cfa_fsync(int fd) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FSYNC) + return fsync(fd); + #else + __submit_prelude + + (*sqe){ IORING_OP_FSYNC, fd }; + + __submit_wait + #endif +} + +int cfa_sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SYNC_FILE_RANGE) + return sync_file_range(fd, offset, nbytes, flags); + #else + __submit_prelude + + (*sqe){ IORING_OP_SYNC_FILE_RANGE, fd }; + sqe->off = offset; + sqe->len = nbytes; + sqe->sync_range_flags = flags; + + __submit_wait + #endif +} + + +ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SENDMSG) + return sendmsg(sockfd, msg, flags); + #else + __submit_prelude + + (*sqe){ IORING_OP_SENDMSG, sockfd, msg, 1, 0 }; + sqe->msg_flags = flags; + + __submit_wait + #endif +} + +ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_RECVMSG) + return recvmsg(sockfd, msg, flags); + #else + __submit_prelude + + (*sqe){ IORING_OP_RECVMSG, sockfd, msg, 1, 0 }; + sqe->msg_flags = flags; + + __submit_wait + #endif +} + +ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SEND) + return send( sockfd, buf, len, flags ); + #else + __submit_prelude + + (*sqe){ IORING_OP_SEND, sockfd }; + sqe->addr = (uint64_t)buf; + sqe->len = len; + sqe->msg_flags = flags; + + __submit_wait + #endif +} + +ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_RECV) + return recv( sockfd, buf, len, flags ); + #else + __submit_prelude + + (*sqe){ IORING_OP_RECV, sockfd }; + sqe->addr = (uint64_t)buf; + sqe->len = len; + sqe->msg_flags = flags; + + __submit_wait + #endif +} + +int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_ACCEPT) + return accept4( sockfd, addr, addrlen, flags ); + #else + __submit_prelude + + (*sqe){ IORING_OP_ACCEPT, sockfd }; + sqe->addr = addr; + sqe->addr2 = addrlen; + sqe->accept_flags = flags; + + __submit_wait + #endif +} + +int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_CONNECT) + return connect( sockfd, addr, addrlen ); + #else + __submit_prelude + + (*sqe){ IORING_OP_CONNECT, sockfd }; + sqe->addr = (uint64_t)addr; + sqe->off = addrlen; + + __submit_wait + #endif +} + +int cfa_fallocate(int fd, int mode, uint64_t offset, uint64_t len) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FALLOCATE) + return fallocate( fd, mode, offset, len ); + #else + __submit_prelude + + (*sqe){ IORING_OP_FALLOCATE, fd }; + sqe->off = offset; + sqe->len = length; + sqe->mode = mode; + + __submit_wait + #endif +} + +int cfa_fadvise(int fd, uint64_t offset, uint64_t len, int advice) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FADVISE) + return posix_fadvise( fd, offset, len, advice ); + #else + __submit_prelude + + (*sqe){ IORING_OP_FADVISE, fd }; + sqe->off = (uint64_t)offset; + sqe->len = length; + sqe->fadvise_advice = advice; + + __submit_wait + #endif +} + +int cfa_madvise(void *addr, size_t length, int advice) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_MADVISE) + return madvise( addr, length, advice ); + #else + __submit_prelude + + (*sqe){ IORING_OP_MADVISE, 0 }; + sqe->addr = (uint64_t)addr; + sqe->len = length; + sqe->fadvise_advice = advice; + + __submit_wait + #endif +} + +int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_OPENAT) + return openat( dirfd, pathname, flags, mode ); + #else + __submit_prelude + + (*sqe){ IORING_OP_OPENAT, dirfd }; + sqe->addr = (uint64_t)pathname; + sqe->open_flags = flags; + sqe->mode = mode; + + __submit_wait + #endif +} + +int cfa_close(int fd) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_CLOSE) + return close( fd ); + #else + __submit_prelude + + (*sqe){ IORING_OP_CLOSE, fd }; + + __submit_wait + #endif +} + + +ssize_t cfa_read(int fd, void *buf, size_t count) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_READ) + return read( fd, buf, count ); + #else + __submit_prelude + + (*sqe){ IORING_OP_READ, fd, buf, count, 0 }; + + __submit_wait + #endif +} + +ssize_t cfa_write(int fd, void *buf, size_t count) { + #if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_WRITE) + return read( fd, buf, count ); + #else + __submit_prelude + + (*sqe){ IORING_OP_WRITE, fd, buf, count, 0 }; + + __submit_wait + #endif +} + +//----------------------------------------------------------------------------- +// Check if a function is asynchronous + +// Macro magic to reduce the size of the following switch case +#define IS_DEFINED_APPLY(f, ...) f(__VA_ARGS__) +#define IS_DEFINED_SECOND(first, second, ...) second +#define IS_DEFINED_TEST(expansion) _CFA_IO_FEATURE_##expansion +#define IS_DEFINED(macro) IS_DEFINED_APPLY( IS_DEFINED_SECOND,IS_DEFINED_TEST(macro) false, true) + +bool has_user_level_blocking( fptr_t func ) { + #if defined(HAVE_LINUX_IO_URING_H) + #if defined(HAVE_PREADV2) + if( /*func == (fptr_t)preadv2 || */ + func == (fptr_t)cfa_preadv2 ) + #define _CFA_IO_FEATURE_IORING_OP_READV , + return IS_DEFINED(IORING_OP_READV); + #endif + + #if defined(HAVE_PWRITEV2) + if( /*func == (fptr_t)pwritev2 || */ + func == (fptr_t)cfa_pwritev2 ) + #define _CFA_IO_FEATURE_IORING_OP_WRITEV , + return IS_DEFINED(IORING_OP_WRITEV); + #endif + + if( /*func == (fptr_t)fsync || */ + func == (fptr_t)cfa_fsync ) + #define _CFA_IO_FEATURE_IORING_OP_FSYNC , + return IS_DEFINED(IORING_OP_FSYNC); + + if( /*func == (fptr_t)ync_file_range || */ + func == (fptr_t)cfa_sync_file_range ) + #define _CFA_IO_FEATURE_IORING_OP_SYNC_FILE_RANGE , + return IS_DEFINED(IORING_OP_SYNC_FILE_RANGE); + + if( /*func == (fptr_t)sendmsg || */ + func == (fptr_t)cfa_sendmsg ) + #define _CFA_IO_FEATURE_IORING_OP_SENDMSG , + return IS_DEFINED(IORING_OP_SENDMSG); + + if( /*func == (fptr_t)recvmsg || */ + func == (fptr_t)cfa_recvmsg ) + #define _CFA_IO_FEATURE_IORING_OP_RECVMSG , + return IS_DEFINED(IORING_OP_RECVMSG); + + if( /*func == (fptr_t)send || */ + func == (fptr_t)cfa_send ) + #define _CFA_IO_FEATURE_IORING_OP_SEND , + return IS_DEFINED(IORING_OP_SEND); + + if( /*func == (fptr_t)recv || */ + func == (fptr_t)cfa_recv ) + #define _CFA_IO_FEATURE_IORING_OP_RECV , + return IS_DEFINED(IORING_OP_RECV); + + if( /*func == (fptr_t)accept4 || */ + func == (fptr_t)cfa_accept4 ) + #define _CFA_IO_FEATURE_IORING_OP_ACCEPT , + return IS_DEFINED(IORING_OP_ACCEPT); + + if( /*func == (fptr_t)connect || */ + func == (fptr_t)cfa_connect ) + #define _CFA_IO_FEATURE_IORING_OP_CONNECT , + return IS_DEFINED(IORING_OP_CONNECT); + + if( /*func == (fptr_t)fallocate || */ + func == (fptr_t)cfa_fallocate ) + #define _CFA_IO_FEATURE_IORING_OP_FALLOCATE , + return IS_DEFINED(IORING_OP_FALLOCATE); + + if( /*func == (fptr_t)posix_fadvise || */ + func == (fptr_t)cfa_fadvise ) + #define _CFA_IO_FEATURE_IORING_OP_FADVISE , + return IS_DEFINED(IORING_OP_FADVISE); + + if( /*func == (fptr_t)madvise || */ + func == (fptr_t)cfa_madvise ) + #define _CFA_IO_FEATURE_IORING_OP_MADVISE , + return IS_DEFINED(IORING_OP_MADVISE); + + if( /*func == (fptr_t)openat || */ + func == (fptr_t)cfa_openat ) + #define _CFA_IO_FEATURE_IORING_OP_OPENAT , + return IS_DEFINED(IORING_OP_OPENAT); + + if( /*func == (fptr_t)close || */ + func == (fptr_t)cfa_close ) + #define _CFA_IO_FEATURE_IORING_OP_CLOSE , + return IS_DEFINED(IORING_OP_CLOSE); + + if( /*func == (fptr_t)read || */ + func == (fptr_t)cfa_read ) + #define _CFA_IO_FEATURE_IORING_OP_READ , + return IS_DEFINED(IORING_OP_READ); + + if( /*func == (fptr_t)write || */ + func == (fptr_t)cfa_write ) + #define _CFA_IO_FEATURE_IORING_OP_WRITE , + return IS_DEFINED(IORING_OP_WRITE); + #endif + + return false; +} Index: libcfa/src/concurrency/iofwd.hfa =================================================================== --- libcfa/src/concurrency/iofwd.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ libcfa/src/concurrency/iofwd.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,39 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// iofwd.hfa -- +// +// Author : Thierry Delisle +// Created On : Thu Apr 23 17:31:00 2020 +// Last Modified By : +// Last Modified On : +// Update Count : +// + +#pragma once + +ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags); +ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags); +int cfa_fsync(int fd); +int cfa_sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags); +ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags); +ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags); +ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags); +ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags); +int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags); +int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen); +int cfa_fallocate(int fd, int mode, uint64_t offset, uint64_t len); +int cfa_fadvise(int fd, uint64_t offset, uint64_t len, int advice); +int cfa_madvise(void *addr, size_t length, int advice); +int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode); +int cfa_close(int fd); +int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf); +ssize_t cfa_read(int fd, void *buf, size_t count); +ssize_t cfa_write(int fd, void *buf, size_t count) + +//----------------------------------------------------------------------------- +// Check if a function is blocks a only the user thread +bool has_user_level_blocking( fptr_t func ); Index: libcfa/src/concurrency/kernel.cfa =================================================================== --- libcfa/src/concurrency/kernel.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/concurrency/kernel.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -15,4 +15,5 @@ #define __cforall_thread__ +// #define __CFA_DEBUG_PRINT_RUNTIME_CORE__ //C Includes @@ -40,4 +41,5 @@ #include "invoke.h" + //----------------------------------------------------------------------------- // Some assembly required @@ -230,14 +232,14 @@ idle{}; - __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", &this); + __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this); this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this ); - __cfaabi_dbg_print_safe("Kernel : core %p started\n", &this); + __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this); } void ^?{}(processor & this) with( this ){ if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) { - __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this); + __cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this); __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED); @@ -248,9 +250,11 @@ } - pthread_join( kernel_thread, 0p ); + int err = pthread_join( kernel_thread, 0p ); + if( err != 0 ) abort("KERNEL ERROR: joining processor %p caused error %s\n", &this, strerror(err)); + free( this.stack ); } -void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) { +void ?{}(cluster & this, const char name[], Duration preemption_rate, int io_flags) with( this ) { this.name = name; this.preemption_rate = preemption_rate; @@ -258,12 +262,20 @@ ready_queue_lock{}; + #if !defined(__CFA_NO_STATISTICS__) + print_stats = false; + #endif + procs{ __get }; idles{ __get }; threads{ __get }; + __kernel_io_startup( this, io_flags, &this == mainCluster ); + doregister(this); } void ^?{}(cluster & this) { + __kernel_io_shutdown( this, &this == mainCluster ); + unregister(this); } @@ -281,5 +293,5 @@ verify(this); - __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this); + __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this); doregister(this->cltr, this); @@ -289,5 +301,5 @@ preemption_scope scope = { this }; - __cfaabi_dbg_print_safe("Kernel : core %p started\n", this); + __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this); $thread * readyThread = 0p; @@ -315,5 +327,5 @@ } - __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this); + __cfadbg_print_safe(runtime_core, "Kernel : core %p stopping\n", this); } @@ -322,5 +334,5 @@ V( this->terminated ); - __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this); + __cfadbg_print_safe(runtime_core, "Kernel : core %p terminated\n", this); // HACK : the coroutine context switch expects this_thread to be set @@ -467,5 +479,5 @@ //We now have a proper context from which to schedule threads - __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx); + __cfadbg_print_safe(runtime_core, "Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx); // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't @@ -478,5 +490,5 @@ // Main routine of the core returned, the core is now fully terminated - __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner); + __cfadbg_print_safe(runtime_core, "Kernel : core %p main ended (%p)\n", proc, &proc->runner); return 0p; @@ -611,8 +623,6 @@ } -void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) { - if( !thrd ) return; - - disable_interrupts(); +// KERNEL ONLY unpark with out disabling interrupts +void __unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) { static_assert(sizeof(thrd->state) == sizeof(int)); @@ -643,4 +653,11 @@ abort(); } +} + +void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) { + if( !thrd ) return; + + disable_interrupts(); + __unpark( thrd __cfaabi_dbg_ctx_fwd2 ); enable_interrupts( __cfaabi_dbg_ctx ); } @@ -704,5 +721,5 @@ static void __kernel_startup(void) { verify( ! kernelTLS.preemption_state.enabled ); - __cfaabi_dbg_print_safe("Kernel : Starting\n"); + __cfadbg_print_safe(runtime_core, "Kernel : Starting\n"); __page_size = sysconf( _SC_PAGESIZE ); @@ -715,5 +732,5 @@ (*mainCluster){"Main Cluster"}; - __cfaabi_dbg_print_safe("Kernel : Main cluster ready\n"); + __cfadbg_print_safe(runtime_core, "Kernel : Main cluster ready\n"); // Start by initializing the main thread @@ -725,5 +742,5 @@ (*mainThread){ &info }; - __cfaabi_dbg_print_safe("Kernel : Main thread ready\n"); + __cfadbg_print_safe(runtime_core, "Kernel : Main thread ready\n"); @@ -746,5 +763,5 @@ runner{ &this }; - __cfaabi_dbg_print_safe("Kernel : constructed main processor context %p\n", &runner); + __cfadbg_print_safe(runtime_core, "Kernel : constructed main processor context %p\n", &runner); } @@ -771,7 +788,12 @@ - // THE SYSTEM IS NOW COMPLETELY RUNNING - __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n"); + + + // Now that the system is up, finish creating systems that need threading + __kernel_io_finish_start( *mainCluster ); + + + __cfadbg_print_safe(runtime_core, "Kernel : Started\n--------------------------------------------------\n\n"); verify( ! kernelTLS.preemption_state.enabled ); @@ -781,9 +803,12 @@ static void __kernel_shutdown(void) { - __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n"); + //Before we start shutting things down, wait for systems that need threading to shutdown + __kernel_io_prepare_stop( *mainCluster ); /* paranoid */ verify( TL_GET( preemption_state.enabled ) ); disable_interrupts(); /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); + + __cfadbg_print_safe(runtime_core, "\n--------------------------------------------------\nKernel : Shutting down\n"); // SKULLDUGGERY: Notify the mainProcessor it needs to terminates. @@ -801,4 +826,8 @@ // Destroy the main processor and its context in reverse order of construction // These were manually constructed so we need manually destroy them + void ^?{}(processor & this) with( this ){ + /* paranoid */ verify( this.do_terminate == true ); + } + ^(*mainProcessor){}; @@ -808,8 +837,10 @@ ^(*mainThread){}; + ^(*mainCluster){}; + ^(__cfa_dbg_global_clusters.list){}; ^(__cfa_dbg_global_clusters.lock){}; - __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n"); + __cfadbg_print_safe(runtime_core, "Kernel : Shutdown complete\n"); } @@ -836,9 +867,9 @@ // We are ready to sleep - __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this); + __cfadbg_print_safe(runtime_core, "Kernel : Processor %p ready to sleep\n", this); wait( idle ); // We have woken up - __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this); + __cfadbg_print_safe(runtime_core, "Kernel : Processor %p woke up and ready to run\n", this); // Get ourself off the idle list @@ -856,5 +887,5 @@ static bool __wake_one(cluster * this, __attribute__((unused)) bool force) { // if we don't want to force check if we know it's false - if( !this->idles.head && !force ) return false; + // if( !this->idles.head && !force ) return false; // First, lock the cluster idle @@ -869,4 +900,6 @@ // Wake them up + __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this->idles.head); + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); post( this->idles.head->idle ); @@ -878,5 +911,12 @@ // Unconditionnaly wake a thread static bool __wake_proc(processor * this) { - return post( this->idle ); + __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this); + + disable_interrupts(); + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); + bool ret = post( this->idle ); + enable_interrupts( __cfaabi_dbg_ctx ); + + return ret; } @@ -960,5 +1000,5 @@ void ^?{}(semaphore & this) {} -void P(semaphore & this) with( this ){ +bool P(semaphore & this) with( this ){ lock( lock __cfaabi_dbg_ctx2 ); count -= 1; @@ -970,7 +1010,9 @@ unlock( lock ); park( __cfaabi_dbg_ctx ); + return true; } else { unlock( lock ); + return false; } } @@ -989,4 +1031,18 @@ // make new owner unpark( thrd __cfaabi_dbg_ctx2 ); + + return thrd != 0p; +} + +bool V(semaphore & this, unsigned diff) with( this ) { + $thread * thrd = 0p; + lock( lock __cfaabi_dbg_ctx2 ); + int release = max(-count, (int)diff); + count += diff; + for(release) { + unpark( pop_head( waiting ) __cfaabi_dbg_ctx2 ); + } + + unlock( lock ); return thrd != 0p; Index: libcfa/src/concurrency/kernel.hfa =================================================================== --- libcfa/src/concurrency/kernel.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/concurrency/kernel.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -17,4 +17,5 @@ #include +#include #include "invoke.h" @@ -37,6 +38,7 @@ void ?{}(semaphore & this, int count = 1); void ^?{}(semaphore & this); -void P (semaphore & this); +bool P (semaphore & this); bool V (semaphore & this); +bool V (semaphore & this, unsigned count); @@ -111,4 +113,11 @@ //----------------------------------------------------------------------------- +// I/O +struct __io_data; + +#define CFA_CLUSTER_IO_POLLER_USER_THREAD 1 << 0 +// #define CFA_CLUSTER_IO_POLLER_KERNEL_SIDE 1 << 1 + +//----------------------------------------------------------------------------- // Cluster struct cluster { @@ -141,13 +150,22 @@ cluster * prev; } node; + + struct __io_data * io; + + #if !defined(__CFA_NO_STATISTICS__) + bool print_stats; + #endif }; extern Duration default_preemption(); -void ?{} (cluster & this, const char name[], Duration preemption_rate); +void ?{} (cluster & this, const char name[], Duration preemption_rate, int flags); void ^?{}(cluster & this); -static inline void ?{} (cluster & this) { this{"Anonymous Cluster", default_preemption()}; } -static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; } -static inline void ?{} (cluster & this, const char name[]) { this{name, default_preemption()}; } +static inline void ?{} (cluster & this) { this{"Anonymous Cluster", default_preemption(), 0}; } +static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate, 0}; } +static inline void ?{} (cluster & this, const char name[]) { this{name, default_preemption(), 0}; } +static inline void ?{} (cluster & this, int flags) { this{"Anonymous Cluster", default_preemption(), flags}; } +static inline void ?{} (cluster & this, Duration preemption_rate, int flags) { this{"Anonymous Cluster", preemption_rate, flags}; } +static inline void ?{} (cluster & this, const char name[], int flags) { this{name, default_preemption(), flags}; } static inline [cluster *&, cluster *& ] __get( cluster & this ) __attribute__((const)) { return this.node.[next, prev]; } @@ -156,4 +174,10 @@ static inline struct cluster * active_cluster () { return TL_GET( this_processor )->cltr; } +#if !defined(__CFA_NO_STATISTICS__) + static inline void print_stats_at_exit( cluster & this ) { + this.print_stats = true; + } +#endif + // Local Variables: // // mode: c // Index: libcfa/src/concurrency/kernel_private.hfa =================================================================== --- libcfa/src/concurrency/kernel_private.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/concurrency/kernel_private.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -59,4 +59,6 @@ extern volatile thread_local __cfa_kernel_preemption_state_t preemption_state __attribute__ ((tls_model ( "initial-exec" ))); +extern cluster * mainCluster; + //----------------------------------------------------------------------------- // Threads @@ -69,4 +71,14 @@ extern void __cfaabi_dbg_thread_unregister( $thread * thrd ); ) + +// KERNEL ONLY unpark with out disabling interrupts +void __unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ); + +//----------------------------------------------------------------------------- +// I/O +void __kernel_io_startup ( cluster &, int, bool ); +void __kernel_io_finish_start( cluster & ); +void __kernel_io_prepare_stop( cluster & ); +void __kernel_io_shutdown ( cluster &, bool ); //----------------------------------------------------------------------------- Index: libcfa/src/concurrency/preemption.cfa =================================================================== --- libcfa/src/concurrency/preemption.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/concurrency/preemption.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -43,4 +43,5 @@ // FwdDeclarations : Signal handlers static void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ); +static void sigHandler_alarm ( __CFA_SIGPARMS__ ); static void sigHandler_segv ( __CFA_SIGPARMS__ ); static void sigHandler_ill ( __CFA_SIGPARMS__ ); @@ -83,6 +84,6 @@ // Get next expired node static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) { - if( !alarms->head ) return 0p; // If no alarms return null - if( alarms->head->alarm >= currtime ) return 0p; // If alarms head not expired return null + if( ! & (*alarms)`first ) return 0p; // If no alarms return null + if( (*alarms)`first.alarm >= currtime ) return 0p; // If alarms head not expired return null return pop(alarms); // Otherwise just pop head } @@ -97,4 +98,8 @@ while( node = get_expired( alarms, currtime ) ) { // __cfaabi_dbg_print_buffer_decl( " KERNEL: preemption tick.\n" ); + Duration period = node->period; + if( period == 0) { + node->set = false; // Node is one-shot, just mark it as not pending + } // Check if this is a kernel @@ -107,5 +112,4 @@ // Check if this is a periodic alarm - Duration period = node->period; if( period > 0 ) { // __cfaabi_dbg_print_buffer_local( " KERNEL: alarm period is %lu.\n", period.tv ); @@ -113,18 +117,15 @@ insert( alarms, node ); // Reinsert the node for the next time it triggers } - else { - node->set = false; // Node is one-shot, just mark it as not pending - } } // If there are still alarms pending, reset the timer - if( alarms->head ) { + if( & (*alarms)`first ) { __cfaabi_dbg_print_buffer_decl( " KERNEL: @%ju(%ju) resetting alarm to %ju.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv); - Duration delta = alarms->head->alarm - currtime; - Duration caped = max(delta, 50`us); + Duration delta = (*alarms)`first.alarm - currtime; + Duration capped = max(delta, 50`us); // itimerval tim = { caped }; // __cfaabi_dbg_print_buffer_local( " Values are %lu, %lu, %lu %lu.\n", delta.tv, caped.tv, tim.it_value.tv_sec, tim.it_value.tv_usec); - __kernel_set_timer( caped ); + __kernel_set_timer( capped ); } } @@ -256,5 +257,5 @@ if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) { - abort( "internal error, pthread_sigmask" ); + abort( "internal error, pthread_sigmask" ); } } @@ -268,5 +269,5 @@ // reserved for future use static void timeout( $thread * this ) { - //TODO : implement waking threads + __unpark( this __cfaabi_dbg_ctx2 ); } @@ -303,4 +304,5 @@ // Setup proper signal handlers __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // __cfactx_switch handler + __cfaabi_sigaction( SIGALRM, sigHandler_alarm , SA_SIGINFO | SA_RESTART ); // debug handler signal_block( SIGALRM ); @@ -394,4 +396,8 @@ force_yield( __ALARM_PREEMPTION ); // Do the actual __cfactx_switch +} + +static void sigHandler_alarm( __CFA_SIGPARMS__ ) { + abort("SIGALRM should never reach the signal handler"); } Index: libcfa/src/concurrency/thread.hfa =================================================================== --- libcfa/src/concurrency/thread.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/concurrency/thread.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -117,4 +117,8 @@ } +//---------- +// sleep: force thread to block and be rescheduled after Duration duration +void sleep( Duration duration ); + // Local Variables: // // mode: c // Index: libcfa/src/containers/list.hfa =================================================================== --- libcfa/src/containers/list.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ libcfa/src/containers/list.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,304 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// list -- lets a user-defined stuct form intrusive linked lists +// +// Author : Michael Brooks +// Created On : Wed Apr 22 18:00:00 2020 +// Last Modified By : Michael Brooks +// Last Modified On : Wed Apr 22 18:00:00 2020 +// Update Count : 1 +// + +#include + +#define __DLISTED_MGD_COMMON(ELEM, NODE, LINKS_FLD) \ +static inline ELEM& $tempcv_n2e(NODE &node) { \ + return node; \ +} \ +\ +static inline NODE& $tempcv_e2n(ELEM &node) { \ + return node; \ +} \ +\ +static inline ELEM & ?`prev(NODE &node) { \ + $dlinks(ELEM) & ls = node.LINKS_FLD; \ + $mgd_link(ELEM) * l = &ls.prev; \ + ELEM * e = l->elem; \ + return *e; \ +} \ +\ +static inline ELEM & ?`next(NODE &node) { \ + $dlinks(ELEM) & ls = node.LINKS_FLD; \ + $mgd_link(ELEM) * l = &ls.next; \ + ELEM * e = l->elem; \ + return *e; \ +} \ +\ +static inline $mgd_link(ELEM) & $prev_link(NODE &node) { \ + $dlinks(ELEM) & ls = node.LINKS_FLD; \ + $mgd_link(ELEM) * l = &ls.prev; \ + return *l; \ +} \ +\ +static inline $mgd_link(ELEM) & $next_link(NODE &node) { \ + $dlinks(ELEM) & ls = node.LINKS_FLD; \ + $mgd_link(ELEM) * l = &ls.next; \ + return *l; \ +} + +#define __DLISTED_MGD_JUSTEXPL(STRUCT, IN_THELIST, STRUCT_IN_THELIST) \ +struct STRUCT_IN_THELIST { \ + inline STRUCT; \ +}; \ +\ +void ?{}(STRUCT_IN_THELIST &) = void; \ +\ +static inline STRUCT_IN_THELIST& ?`IN_THELIST(STRUCT &this) { \ + return (STRUCT_IN_THELIST&)this; \ +} + +#define __DLISTED_MGD_JUSTIMPL(STRUCT) + +forall( dtype tE ) { + struct $mgd_link { + tE *elem; + void *terminator; + _Bool is_terminator; + // will collapse to single pointer with tag bit + }; + static inline void ?{}( $mgd_link(tE) &this, tE* elem ) { + (this.elem){ elem }; + (this.terminator){ 0p }; + (this.is_terminator){ 0 }; + } + static inline void ?{}( $mgd_link(tE) &this, void * terminator ) { + (this.elem){ 0p }; + (this.terminator){ terminator }; + (this.is_terminator){ 1 }; + } + forall ( otype tInit | { void ?{}( $mgd_link(tE) &, tInit); } ) + static inline void ?=?( $mgd_link(tE) &this, tInit i ) { + ^?{}( this ); + ?{}( this, i ); + } + struct $dlinks { + // containing item is not listed + // iff + // links have (elem == 0p && terminator == 0p) + $mgd_link(tE) next; + $mgd_link(tE) prev; + }; + static inline void ?{}( $dlinks(tE) &this ) { + (this.next){ (tE *)0p }; + (this.prev){ (tE *)0p }; + } +} + +#define DLISTED_MGD_EXPL_IN(STRUCT, LIST_SUF) \ + $dlinks(STRUCT) $links_ ## LIST_SUF; + +#define DLISTED_MGD_EXPL_OUT(STRUCT, LIST_SUF) \ + __DLISTED_MGD_JUSTEXPL(STRUCT, in_##LIST_SUF, STRUCT ## _in_ ## LIST_SUF) \ + __DLISTED_MGD_COMMON(STRUCT, STRUCT##_in_##LIST_SUF, $links_ ## LIST_SUF) + +#define DLISTED_MGD_IMPL_IN(STRUCT) \ + $dlinks(STRUCT) $links; + +#define DLISTED_MGD_IMPL_OUT(STRUCT) \ + __DLISTED_MGD_JUSTIMPL(STRUCT) \ + __DLISTED_MGD_COMMON(STRUCT, STRUCT, $links) + +trait $dlistable(dtype Tnode, dtype Telem) { + $mgd_link(Telem) & $prev_link(Tnode &); + $mgd_link(Telem) & $next_link(Tnode &); + Telem& $tempcv_n2e(Tnode &); + Tnode& $tempcv_e2n(Telem &); +}; + +forall (dtype Tnode, dtype Telem | $dlistable(Tnode, Telem)) { + + // implemented as a sentinel item in an underlying cicrular list + // theList.$links.next is first + // theList.$links.prev is last + // note this allocation preserves prev-next composition as an identity + struct dlist { + $dlinks(Telem) $links; + }; + + // an empty dlist + // links refer to self, making a tight circle + static inline void ?{}( dlist(Tnode, Telem) & this ) { + $mgd_link(Telem) selfRef = (void *) &this; + ( this.$links ) { selfRef, selfRef }; + } + + static inline Telem & ?`first( dlist(Tnode, Telem) &l ) { + return * l.$links.next.elem; + } + + static inline Telem & ?`last( dlist(Tnode, Telem) &l ) { + return * l.$links.prev.elem; + } + + #if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__)) + static bool $validate_fwd( dlist(Tnode, Telem) & this ) { + Tnode * it = & $tempcv_e2n( this`first ); + if (!it) return (& this`last == 0p); + + while( $next_link(*it).elem ) { + it = & $tempcv_e2n( * $next_link(*it).elem ); + } + + return ( it == & $tempcv_e2n( this`last ) ) && + ( $next_link(*it).is_terminator ) && + ( ((dlist(Tnode, Telem)*)$next_link(*it).terminator) == &this ); + } + static bool $validate_rev( dlist(Tnode, Telem) & this ) { + Tnode * it = & $tempcv_e2n( this`last ); + if (!it) return (& this`first == 0p); + + while( $prev_link(*it).elem ) { + it = & $tempcv_e2n( * $prev_link(*it).elem ); + } + + return ( it == & $tempcv_e2n( this`first ) ) && + ( $prev_link(*it).is_terminator ) && + ( ((dlist(Tnode, Telem)*)$prev_link(*it).terminator) == &this ); + } + static bool validate( dlist(Tnode, Telem) & this ) { + return $validate_fwd(this) && $validate_rev(this); + } + #endif + + static inline void insert_after(Tnode &list_pos, Telem &to_insert) { + assert (&list_pos != 0p); + assert (&to_insert != 0p); + Tnode &singleton_to_insert = $tempcv_e2n(to_insert); + assert($prev_link(singleton_to_insert).elem == 0p); + assert($next_link(singleton_to_insert).elem == 0p); + $prev_link(singleton_to_insert) = & $tempcv_n2e(list_pos); + $next_link(singleton_to_insert) = $next_link(list_pos); + if ($next_link(list_pos).is_terminator) { + dlist(Tnode, Telem) *list = $next_link(list_pos).terminator; + $dlinks(Telem) *list_links = & list->$links; + $mgd_link(Telem) *list_last = & list_links->prev; + *list_last = &to_insert; + } else { + Telem *list_pos_next = $next_link(list_pos).elem; + if (list_pos_next) { + Tnode & lpn_inlist = $tempcv_e2n(*list_pos_next); + $prev_link(lpn_inlist) = &to_insert; + } + } + $next_link(list_pos) = &to_insert; + } + + static inline void insert_before(Tnode &list_pos, Telem &to_insert) { + assert (&list_pos != 0p); + assert (&to_insert != 0p); + Tnode &singleton_to_insert = $tempcv_e2n(to_insert); + assert($prev_link(singleton_to_insert).elem == 0p); + assert($next_link(singleton_to_insert).elem == 0p); + $next_link(singleton_to_insert) = & $tempcv_n2e(list_pos); + $prev_link(singleton_to_insert) = $prev_link(list_pos); + if ($prev_link(list_pos).is_terminator) { + dlist(Tnode, Telem) *list = $prev_link(list_pos).terminator; + $dlinks(Telem) *list_links = & list->$links; + $mgd_link(Telem) *list_first = & list_links->next; + *list_first = &to_insert; + } else { + Telem *list_pos_prev = $prev_link(list_pos).elem; + if (list_pos_prev) { + Tnode & lpp_inlist = $tempcv_e2n(*list_pos_prev); + $next_link(lpp_inlist) = &to_insert; + } + } + $prev_link(list_pos) = &to_insert; + } + + static inline void insert_first(dlist(Tnode, Telem) &list, Telem &to_insert) { + assert (&list != 0p); + assert (&to_insert != 0p); + Tnode &singleton_to_insert = $tempcv_e2n(to_insert); + assert($prev_link(singleton_to_insert).elem == 0p); + assert($next_link(singleton_to_insert).elem == 0p); + + $prev_link(singleton_to_insert) = (void*) &list; + $next_link(singleton_to_insert) = list.$links.next; + + $dlinks(Telem) *listLinks = & list.$links; + if (listLinks->next.is_terminator) { + $mgd_link(Telem) * listPrevReference = & listLinks->prev; + *listPrevReference = &to_insert; + } else { + Tnode & next_inlist = $tempcv_e2n(*list.$links.next.elem); + $prev_link(next_inlist) = &to_insert; + } + $mgd_link(Telem) * listNextReference = & listLinks->next; + *listNextReference = &to_insert; + } + + static inline void insert_last(dlist(Tnode, Telem) &list, Telem &to_insert) { + assert (&list != 0p); + assert (&to_insert != 0p); + Tnode &singleton_to_insert = $tempcv_e2n(to_insert); + assert($next_link(singleton_to_insert).elem == 0p); + assert($prev_link(singleton_to_insert).elem == 0p); + + $next_link(singleton_to_insert) = (void*) &list; + $prev_link(singleton_to_insert) = list.$links.prev; + + $dlinks(Telem) *listLinks = & list.$links; + if (listLinks->prev.is_terminator) { + $mgd_link(Telem) * listNextReference = & listLinks->next; + *listNextReference = &to_insert; + } else { + Tnode & prev_inlist = $tempcv_e2n(*list.$links.prev.elem); + $next_link(prev_inlist) = &to_insert; + } + $mgd_link(Telem) * listPrevReference = & listLinks->prev; + *listPrevReference = &to_insert; + } + + static inline void remove(Tnode &list_pos) { + assert( &list_pos != 0p ); + + $mgd_link(Telem) &incoming_from_prev = *0p; + $mgd_link(Telem) &incoming_from_next = *0p; + + if ( $prev_link(list_pos).is_terminator ) { + dlist(Tnode, Telem) * tgt_before = $prev_link(list_pos).terminator; + $dlinks(Telem) * links_before = & tgt_before->$links; + &incoming_from_prev = & links_before->next; + } else if ($prev_link(list_pos).elem) { + Telem * tgt_before = $prev_link(list_pos).elem; + Tnode & list_pos_before = $tempcv_e2n(*tgt_before); + &incoming_from_prev = & $next_link(list_pos_before); + } + + if ( $next_link(list_pos).is_terminator ) { + dlist(Tnode, Telem) * tgt_after = $next_link(list_pos).terminator; + $dlinks(Telem) * links_after = & tgt_after->$links; + &incoming_from_next = & links_after->prev; + } else if ($next_link(list_pos).elem) { + Telem * tgt_after = $next_link(list_pos).elem; + Tnode & list_pos_after = $tempcv_e2n(*tgt_after ); + &incoming_from_next = & $prev_link(list_pos_after ); + } + + if (& incoming_from_prev) { + incoming_from_prev = $next_link(list_pos); + } + if (& incoming_from_next) { + incoming_from_next = $prev_link(list_pos); + } + + $next_link(list_pos) = (Telem*) 0p; + $prev_link(list_pos) = (Telem*) 0p; + } +} + Index: libcfa/src/exception.c =================================================================== --- libcfa/src/exception.c (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/exception.c (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -10,6 +10,6 @@ // Created On : Mon Jun 26 15:13:00 2017 // Last Modified By : Andrew Beach -// Last Modified On : Fri Apr 03 11:57:00 2020 -// Update Count : 14 +// Last Modified On : Tue Apr 14 12:01:00 2020 +// Update Count : 18 // @@ -28,4 +28,5 @@ #include #include +#include "stdhdr/assert.h" // FIX ME: temporary hack to keep ARM build working @@ -75,9 +76,14 @@ // RESUMPTION ================================================================ +static void reset_top_resume(struct __cfaehm_try_resume_node ** store) { + this_exception_context()->top_resume = *store; +} + void __cfaehm_throw_resume(exception_t * except) { struct exception_context_t * context = this_exception_context(); - __cfaabi_dbg_print_safe("Throwing resumption exception\n"); - + __cfadbg_print_safe(exception, "Throwing resumption exception\n"); + + __attribute__((cleanup(reset_top_resume))) struct __cfaehm_try_resume_node * original_head = context->top_resume; struct __cfaehm_try_resume_node * current = context->top_resume; @@ -86,11 +92,9 @@ context->top_resume = current->next; if (current->handler(except)) { - context->top_resume = original_head; return; } } - __cfaabi_dbg_print_safe("Unhandled exception\n"); - context->top_resume = original_head; + __cfadbg_print_safe(exception, "Unhandled exception\n"); // Fall back to termination: @@ -176,5 +180,5 @@ struct exception_context_t * context = this_exception_context(); - __cfaabi_dbg_print_safe("Deleting Exception\n"); + __cfadbg_print_safe(exception, "Deleting Exception\n"); // Remove the exception from the list. @@ -213,8 +217,13 @@ struct _Unwind_Context * unwind_context, void * stop_param) { - if ( actions & _UA_END_OF_STACK ) exit(1); - if ( actions & _UA_CLEANUP_PHASE ) return _URC_NO_REASON; - - return _URC_FATAL_PHASE2_ERROR; + // Verify actions follow the rules we expect. + verify((actions & _UA_CLEANUP_PHASE) && (actions & _UA_FORCE_UNWIND)); + verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDER_FRAME))); + + if ( actions & _UA_END_OF_STACK ) { + exit(1); + } else { + return _URC_NO_REASON; + } } @@ -252,5 +261,5 @@ void __cfaehm_throw_terminate( exception_t * val ) { - __cfaabi_dbg_print_safe("Throwing termination exception\n"); + __cfadbg_print_safe(exception, "Throwing termination exception\n"); __cfaehm_allocate_exception( val ); @@ -259,5 +268,5 @@ void __cfaehm_rethrow_terminate(void) { - __cfaabi_dbg_print_safe("Rethrowing termination exception\n"); + __cfadbg_print_safe(exception, "Rethrowing termination exception\n"); __cfaehm_begin_unwind(); @@ -275,21 +284,26 @@ { - //__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context)); - __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):", + //__cfadbg_print_safe(exception, "CFA: 0x%lx\n", _Unwind_GetCFA(context)); + __cfadbg_print_safe(exception, "Personality function (%d, %x, %llu, %p, %p):", version, actions, exception_class, unwind_exception, unwind_context); - // If we've reached the end of the stack then there is nothing much we can do... - if (actions & _UA_END_OF_STACK) return _URC_END_OF_STACK; - + // Verify that actions follow the rules we expect. + // This function should never be called at the end of the stack. + verify(!(actions & _UA_END_OF_STACK)); + // Either only the search phase flag is set or... if (actions & _UA_SEARCH_PHASE) { - __cfaabi_dbg_print_safe(" lookup phase"); - } - else if (actions & _UA_CLEANUP_PHASE) { - __cfaabi_dbg_print_safe(" cleanup phase"); - } - // Just in case, probably can't actually happen - else { - printf(" error\n"); - return _URC_FATAL_PHASE1_ERROR; + verify(actions == _UA_SEARCH_PHASE); + __cfadbg_print_safe(exception, " lookup phase"); + // ... we are in clean-up phase. + } else { + verify(actions & _UA_CLEANUP_PHASE); + __cfadbg_print_safe(exception, " cleanup phase"); + // We shouldn't be the handler frame during forced unwind. + if (actions & _UA_HANDLER_FRAME) { + verify(!(actions & _UA_FORCE_UNWIND)); + __cfadbg_print_safe(exception, " (handler frame)"); + } else if (actions & _UA_FORCE_UNWIND) { + __cfadbg_print_safe(exception, " (force unwind)"); + } } @@ -331,5 +345,5 @@ void * ep = (void*)lsd_info.Start + callsite_start + callsite_len; void * ip = (void*)instruction_ptr; - __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", + __cfadbg_print_safe(exception, "\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip); #endif // __CFA_DEBUG_PRINT__ @@ -346,5 +360,5 @@ if ( 0 == callsite_landing_pad ) { // Nothing to do, move along - __cfaabi_dbg_print_safe(" no landing pad"); + __cfadbg_print_safe(exception, " no landing pad"); } else if (actions & _UA_SEARCH_PHASE) { // In search phase, these means we found a potential handler we must check. @@ -384,7 +398,7 @@ // Based on the return value, check if we matched the exception if (ret == _URC_HANDLER_FOUND) { - __cfaabi_dbg_print_safe(" handler found\n"); + __cfadbg_print_safe(exception, " handler found\n"); } else { - __cfaabi_dbg_print_safe(" no handler\n"); + __cfadbg_print_safe(exception, " no handler\n"); } return ret; @@ -392,6 +406,6 @@ // This is only a cleanup handler, ignore it - __cfaabi_dbg_print_safe(" no action"); - } else if (actions & _UA_CLEANUP_PHASE) { + __cfadbg_print_safe(exception, " no action"); + } else { // In clean-up phase, no destructors here but this could be the handler. @@ -414,5 +428,5 @@ _Unwind_SetIP( unwind_context, ((lsd_info.LPStart) + (callsite_landing_pad)) ); - __cfaabi_dbg_print_safe(" action\n"); + __cfadbg_print_safe(exception, " action\n"); // Return have some action to run @@ -421,8 +435,8 @@ } // No handling found - __cfaabi_dbg_print_safe(" table end reached\n"); + __cfadbg_print_safe(exception, " table end reached"); UNWIND: - __cfaabi_dbg_print_safe(" unwind\n"); + __cfadbg_print_safe(exception, " unwind\n"); // Keep unwinding the stack @@ -431,5 +445,5 @@ #pragma GCC push_options -#pragma GCC optimize("O0") +#pragma GCC optimize(0) // Try statements are hoisted out see comments for details. While this could probably be unique @@ -528,5 +542,5 @@ " .quad __gcfa_personality_v0\n" #else // then __i386 - " .long __gcfa_personality_v0\n" + " .long __gcfa_personality_v0\n" #endif ); Index: libcfa/src/exception.hfa =================================================================== --- libcfa/src/exception.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ libcfa/src/exception.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,106 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// exception.hfa -- User facing tools for working with exceptions. +// +// Author : Andrew Beach +// Created On : Thu Apr 7 10:25:00 2020 +// Last Modified By : Andrew Beach +// Last Modified On : Thu Apr 7 10:25:00 2020 +// Update Count : 0 +// + +// Everything below this line should be considered a patch while the exception +// objects themselves are designed and created and should be removed in time. +// ----------------------------------------------------------------------------------------------- + +// All internals helper macros begin with an underscore. +#define _CLOSE(...) __VA_ARGS__ } +#define _GLUE2(left, right) left##right +#define _GLUE3(left, middle, right) left##middle##right +#define _EXC_DISPATCH(to, ...) to(__VA_ARGS__,__cfaehm_base_exception_t,) + +// FWD_TRIVIAL_EXCEPTION(exception_name); +// Declare a trivial exception, one that adds no fields or features. +// This will make the exception visible and may go in a .hfa or .cfa file. +#define FWD_TRIVIAL_EXCEPTION(...) _EXC_DISPATCH(_FWD_TRIVIAL_EXCEPTION, __VA_ARGS__) +// INST_TRIVIAL_EXCEPTION(exception_name); +// Create the trival exception. This must be used exactly once and should be used in a .cfa file, +// as it creates the unique instance of the virtual table. +#define INST_TRIVIAL_EXCEPTION(...) _EXC_DISPATCH(_INST_TRIVIAL_EXCEPTION, __VA_ARGS__) +// TRIVIAL_EXCEPTION(exception_name[, parent_name]); +// Does both of the above, a short hand if the exception is only used in one .cfa file. +// For legacy reasons this is the only one that official supports having a parent other than the +// base exception. This feature may be removed or changed. +#define TRIVIAL_EXCEPTION(...) \ + _EXC_DISPATCH(_FWD_TRIVIAL_EXCEPTION, __VA_ARGS__); \ + _EXC_DISPATCH(_INST_TRIVIAL_EXCEPTION, __VA_ARGS__) +#define _FWD_TRIVIAL_EXCEPTION(exception_name, parent_name, ...) \ + _VTABLE_DECLARATION(exception_name, parent_name)(); \ + struct exception_name { \ + VTABLE_FIELD(exception_name); \ + }; \ + void ?{}(exception_name & this); \ + const char * _GLUE2(exception_name,_msg)(exception_name * this) +#define _INST_TRIVIAL_EXCEPTION(exception_name, parent_name, ...) \ + void ?{}(exception_name & this) { \ + VTABLE_INIT(this, exception_name); \ + } \ + const char * _GLUE2(exception_name,_msg)(exception_name * this) { \ + return #exception_name; \ + } \ + _VTABLE_INSTANCE(exception_name, parent_name,)(_GLUE2(exception_name,_msg)) + +// DATA_EXCEPTION(exception_name)(fields...); +// Forward declare an exception that adds fields but no features. The added fields go in the +// second argument list. The virtual table instance must be provided later (see VTABLE_INSTANCE). +#define DATA_EXCEPTION(...) _EXC_DISPATCH(_DATA_EXCEPTION, __VA_ARGS__) +#define _DATA_EXCEPTION(exception_name, parent_name, ...) \ + _VTABLE_DECLARATION(exception_name, parent_name)(); \ + struct exception_name { VTABLE_FIELD(exception_name); _CLOSE + +// VTABLE_DECLARATION(exception_name)([new_features...]); +// Declare a virtual table type for an exception with exception_name. You may also add features +// (fields on the virtual table) by including them in the second list. +#define VTABLE_DECLARATION(...) _EXC_DISPATCH(_VTABLE_DECLARATION, __VA_ARGS__) +#define _VTABLE_DECLARATION(exception_name, parent_name, ...) \ + struct exception_name; \ + VTABLE_TYPE(exception_name); \ + extern VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name); \ + VTABLE_TYPE(exception_name) { \ + VTABLE_TYPE(parent_name) const * parent; \ + size_t size; \ + void (*copy)(exception_name * this, exception_name * other); \ + void (*free)(exception_name & this); \ + const char * (*msg)(exception_name * this); \ + _CLOSE + +// VTABLE_INSTANCE(exception_name)(msg [, others...]); +// Create the instance of the virtual table. There must be exactly one instance of a virtual table +// for each exception type. This fills in most of the fields of the virtual table (uses ?=? and +// ^?{}) but you must provide the message function and any other fields added in the declaration. +#define VTABLE_INSTANCE(...) _EXC_DISPATCH(_VTABLE_INSTANCE, __VA_ARGS__) +#define _VTABLE_INSTANCE(exception_name, parent_name, ...) \ + void _GLUE2(exception_name,_copy)(exception_name * this, exception_name * other) { \ + *this = *other; \ + } \ + VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name) @= { \ + &VTABLE_NAME(parent_name), sizeof(exception_name), \ + _GLUE2(exception_name,_copy), ^?{}, \ + _CLOSE + +// VTABLE_TYPE(exception_name) | VTABLE_NAME(exception_name) +// Get the name of the vtable type or the name of the vtable instance for an exception type. +#define VTABLE_TYPE(exception_name) struct _GLUE2(exception_name,_vtable) +#define VTABLE_NAME(exception_name) _GLUE3(_,exception_name,_vtable_instance) + +// VTABLE_FIELD(exception_name); +// The declaration of the virtual table field. Should be the first declaration in a virtual type. +#define VTABLE_FIELD(exception_name) VTABLE_TYPE(exception_name) const * virtual_table + +// VTABLE_INIT(object_reference, exception_name); +// Sets a virtual table field on an object to the virtual table instance for the type. +#define VTABLE_INIT(this, exception_name) (this).virtual_table = &VTABLE_NAME(exception_name) Index: libcfa/src/heap.cfa =================================================================== --- libcfa/src/heap.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/heap.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -10,6 +10,6 @@ // Created On : Tue Dec 19 21:58:35 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Apr 1 15:59:53 2020 -// Update Count : 692 +// Last Modified On : Wed May 6 17:29:26 2020 +// Update Count : 727 // @@ -19,9 +19,9 @@ #include // errno #include // memset, memcpy +#include // ULONG_MAX extern "C" { #include // mmap, munmap } // extern "C" -// #comment TD : Many of these should be merged into math I believe #include "bits/align.hfa" // libPow2 #include "bits/defs.hfa" // likely, unlikely @@ -30,4 +30,5 @@ //#include "stdlib.hfa" // bsearchl #include "malloc.h" +#include "bitmanip.hfa" // ceiling #define MIN(x, y) (y > x ? x : y) @@ -81,11 +82,11 @@ }; +size_t default_heap_expansion() __attribute__(( weak )) { + return __CFA_DEFAULT_HEAP_EXPANSION__; +} // default_heap_expansion + size_t default_mmap_start() __attribute__(( weak )) { return __CFA_DEFAULT_MMAP_START__; } // default_mmap_start - -size_t default_heap_expansion() __attribute__(( weak )) { - return __CFA_DEFAULT_HEAP_EXPANSION__; -} // default_heap_expansion @@ -181,5 +182,5 @@ } fake; // FakeHeader } kind; // Kind - uint32_t dimension; // used by calloc-like to remember number of array elements + size_t size; // allocation size in bytes } header; // Header char pad[libAlign() - sizeof( Header )]; @@ -265,8 +266,12 @@ static unsigned long long int free_storage; static unsigned int free_calls; +static unsigned long long int aalloc_storage; +static unsigned int aalloc_calls; static unsigned long long int calloc_storage; static unsigned int calloc_calls; static unsigned long long int memalign_storage; static unsigned int memalign_calls; +static unsigned long long int amemalign_storage; +static unsigned int amemalign_calls; static unsigned long long int cmemalign_storage; static unsigned int cmemalign_calls; @@ -280,10 +285,12 @@ // Use "write" because streams may be shutdown when calls are made. static void printStats() { - char helpText[512]; + char helpText[1024]; __cfaabi_bits_print_buffer( STDERR_FILENO, helpText, sizeof(helpText), "\nHeap statistics:\n" " malloc: calls %u / storage %llu\n" + " aalloc: calls %u / storage %llu\n" " calloc: calls %u / storage %llu\n" " memalign: calls %u / storage %llu\n" + " amemalign: calls %u / storage %llu\n" " cmemalign: calls %u / storage %llu\n" " resize: calls %u / storage %llu\n" @@ -294,6 +301,8 @@ " sbrk: calls %u / storage %llu\n", malloc_calls, malloc_storage, + aalloc_calls, calloc_storage, calloc_calls, calloc_storage, memalign_calls, memalign_storage, + amemalign_calls, amemalign_storage, cmemalign_calls, cmemalign_storage, resize_calls, resize_storage, @@ -307,5 +316,5 @@ static int printStatsXML( FILE * stream ) { // see malloc_info - char helpText[512]; + char helpText[1024]; int len = snprintf( helpText, sizeof(helpText), "\n" @@ -314,6 +323,8 @@ "\n" "\n" + "\n" "\n" "\n" + "\n" "\n" "\n" @@ -325,6 +336,8 @@ "", malloc_calls, malloc_storage, + aalloc_calls, aalloc_storage, calloc_calls, calloc_storage, memalign_calls, memalign_storage, + amemalign_calls, amemalign_storage, cmemalign_calls, cmemalign_storage, resize_calls, resize_storage, @@ -348,11 +361,4 @@ -static inline bool setHeapExpand( size_t value ) { - if ( heapExpand < pageSize ) return true; - heapExpand = value; - return false; -} // setHeapExpand - - // thunk problem size_t Bsearchl( unsigned int key, const unsigned int * vals, size_t dim ) { @@ -371,5 +377,5 @@ static inline bool setMmapStart( size_t value ) { // true => mmapped, false => sbrk - if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return true; + if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return false; mmapStart = value; // set global @@ -378,5 +384,5 @@ assert( maxBucketsUsed < NoBucketSizes ); // subscript failure ? assert( mmapStart <= bucketSizes[maxBucketsUsed] ); // search failure ? - return false; + return true; } // setMmapStart @@ -437,5 +443,5 @@ #ifdef __CFA_DEBUG__ - checkHeader( addr < heapBegin || header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ? + checkHeader( addr < heapBegin, name, addr ); // bad low address ? #endif // __CFA_DEBUG__ @@ -496,5 +502,5 @@ // along with the block and is a multiple of the alignment size. - if ( unlikely( size > ~0ul - sizeof(HeapManager.Storage) ) ) return 0p; + if ( unlikely( size > ULONG_MAX - sizeof(HeapManager.Storage) ) ) return 0p; size_t tsize = size + sizeof(HeapManager.Storage); if ( likely( tsize < mmapStart ) ) { // small size => sbrk @@ -548,5 +554,5 @@ block->header.kind.real.home = freeElem; // pointer back to free list of apropriate size } else { // large size => mmap - if ( unlikely( size > ~0ul - pageSize ) ) return 0p; + if ( unlikely( size > ULONG_MAX - pageSize ) ) return 0p; tsize = libCeiling( tsize, pageSize ); // must be multiple of page size #ifdef __STATISTICS__ @@ -566,4 +572,5 @@ } // if + block->header.size = size; // store allocation size void * addr = &(block->data); // adjust off header to user bytes @@ -689,5 +696,5 @@ #endif // FASTLOOKUP - if ( setMmapStart( default_mmap_start() ) ) { + if ( ! setMmapStart( default_mmap_start() ) ) { abort( "HeapManager : internal error, mmap start initialization failure." ); } // if @@ -695,6 +702,5 @@ char * end = (char *)sbrk( 0 ); - sbrk( (char *)libCeiling( (long unsigned int)end, libAlign() ) - end ); // move start of heap to multiple of alignment - heapBegin = heapEnd = sbrk( 0 ); // get new start point + heapBegin = heapEnd = sbrk( (char *)libCeiling( (long unsigned int)end, libAlign() ) - end ); // move start of heap to multiple of alignment } // HeapManager @@ -722,5 +728,5 @@ //assert( heapManager.heapBegin != 0 ); //heapManager{}; - if ( heapManager.heapBegin == 0p ) heapManager{}; + if ( heapManager.heapBegin == 0p ) heapManager{}; // sanity check } // memory_startup @@ -734,4 +740,7 @@ //assert( heapManager.heapBegin != 0 ); if ( unlikely( heapManager.heapBegin == 0p ) ) heapManager{}; // called before memory_startup ? +#if __SIZEOF_POINTER__ == 8 + verify( size < ((typeof(size_t))1 << 48) ); +#endif // __SIZEOF_POINTER__ == 8 void * addr = doMalloc( size ); if ( unlikely( addr == 0p ) ) errno = ENOMEM; // POSIX @@ -740,6 +749,6 @@ -static inline void * callocNoStats( size_t noOfElems, size_t elemSize ) { - size_t size = noOfElems * elemSize; +static inline void * callocNoStats( size_t dim, size_t elemSize ) { + size_t size = dim * elemSize; char * addr = (char *)mallocNoStats( size ); if ( unlikely( addr == 0p ) ) return 0p; @@ -758,6 +767,4 @@ memset( addr, '\0', bsize - sizeof(HeapManager.Storage) ); // set to zeros - assert( noOfElems <= UINT32_MAX ); - header->dimension = noOfElems; // store number of array elements header->kind.real.blockSize |= 2; // mark as zero filled return addr; @@ -801,6 +808,6 @@ -static inline void * cmemalignNoStats( size_t alignment, size_t noOfElems, size_t elemSize ) { - size_t size = noOfElems * elemSize; +static inline void * cmemalignNoStats( size_t alignment, size_t dim, size_t elemSize ) { + size_t size = dim * elemSize; char * addr = (char *)memalignNoStats( alignment, size ); if ( unlikely( addr == 0p ) ) return 0p; @@ -815,6 +822,4 @@ memset( addr, '\0', dataStorage( bsize, addr, header ) ); // set to zeros - assert( noOfElems <= UINT32_MAX ); - header->dimension = noOfElems; // store initial array size header->kind.real.blockSize |= 2; // mark as zero filled return addr; @@ -832,6 +837,6 @@ extern "C" { - // Allocates size bytes and returns a pointer to the allocated memory. The memory is not initialized. If size is 0, - // then malloc() returns either 0p, or a unique pointer value that can later be successfully passed to free(). + // Allocates size bytes and returns a pointer to the allocated memory. The contents are undefined. If size is 0, + // then malloc() returns a unique pointer value that can later be successfully passed to free(). void * malloc( size_t size ) { #ifdef __STATISTICS__ @@ -843,21 +848,30 @@ } // malloc - // Allocate memory for an array of nmemb elements of size bytes each and returns a pointer to the allocated - // memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either 0p, or a unique pointer - // value that can later be successfully passed to free(). - void * calloc( size_t noOfElems, size_t elemSize ) { + + // Same as malloc() except size bytes is an array of dim elements each of elemSize bytes. + void * aalloc( size_t dim, size_t elemSize ) { + #ifdef __STATISTICS__ + __atomic_add_fetch( &aalloc_calls, 1, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &aalloc_storage, dim * elemSize, __ATOMIC_SEQ_CST ); + #endif // __STATISTICS__ + + return mallocNoStats( dim * elemSize ); + } // aalloc + + + // Same as aalloc() with memory set to zero. + void * calloc( size_t dim, size_t elemSize ) { #ifdef __STATISTICS__ __atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST ); - __atomic_add_fetch( &calloc_storage, noOfElems * elemSize, __ATOMIC_SEQ_CST ); - #endif // __STATISTICS__ - - return callocNoStats( noOfElems, elemSize ); + __atomic_add_fetch( &calloc_storage, dim * elemSize, __ATOMIC_SEQ_CST ); + #endif // __STATISTICS__ + + return callocNoStats( dim, elemSize ); } // calloc - // Change the size of the memory block pointed to by ptr to size bytes. The contents are undefined. If ptr is 0p, - // then the call is equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not 0p, - // then the call is equivalent to free(ptr). Unless ptr is 0p, it must have been returned by an earlier call to - // malloc(), calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done. - + // Change the size of the memory block pointed to by oaddr to size bytes. The contents are undefined. If oaddr is + // 0p, then the call is equivalent to malloc(size), for all values of size; if size is equal to zero, and oaddr is + // not 0p, then the call is equivalent to free(oaddr). Unless oaddr is 0p, it must have been returned by an earlier + // call to malloc(), alloc(), calloc() or realloc(). If the area pointed to was moved, a free(oaddr) is done. void * resize( void * oaddr, size_t size ) { #ifdef __STATISTICS__ @@ -874,8 +888,8 @@ size_t bsize, oalign = 0; headers( "resize", oaddr, header, freeElem, bsize, oalign ); + size_t odsize = dataStorage( bsize, oaddr, header ); // data storage available in bucket - // same size, DO NOT preserve STICKY PROPERTIES. - if ( oalign == 0 && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size + if ( oalign == 0 && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size header->kind.real.blockSize &= -2; // no alignment and turn off 0 fill return oaddr; @@ -883,11 +897,11 @@ // change size, DO NOT preserve STICKY PROPERTIES. + free( oaddr ); void * naddr = mallocNoStats( size ); // create new area - free( oaddr ); return naddr; } // resize - // Same as resize but the contents shall be unchanged in the range from the start of the region up to the minimum of + // Same as resize() but the contents are unchanged in the range from the start of the region up to the minimum of // the old and new sizes. void * realloc( void * oaddr, size_t size ) { @@ -939,6 +953,5 @@ } // realloc - // Allocates size bytes and returns a pointer to the allocated memory. The memory address shall be a multiple of - // alignment, which must be a power of two. (obsolete) + // Same as malloc() except the memory address is a multiple of alignment, which must be a power of two. (obsolete) void * memalign( size_t alignment, size_t size ) { #ifdef __STATISTICS__ @@ -951,12 +964,23 @@ + // Same as aalloc() with memory alignment. + void * amemalign( size_t alignment, size_t dim, size_t elemSize ) { + #ifdef __STATISTICS__ + __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST ); + __atomic_add_fetch( &cmemalign_storage, dim * elemSize, __ATOMIC_SEQ_CST ); + #endif // __STATISTICS__ + + return memalignNoStats( alignment, dim * elemSize ); + } // amemalign + + // Same as calloc() with memory alignment. - void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ) { + void * cmemalign( size_t alignment, size_t dim, size_t elemSize ) { #ifdef __STATISTICS__ __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST ); - __atomic_add_fetch( &cmemalign_storage, noOfElems * elemSize, __ATOMIC_SEQ_CST ); - #endif // __STATISTICS__ - - return cmemalignNoStats( alignment, noOfElems, elemSize ); + __atomic_add_fetch( &cmemalign_storage, dim * elemSize, __ATOMIC_SEQ_CST ); + #endif // __STATISTICS__ + + return cmemalignNoStats( alignment, dim, elemSize ); } // cmemalign @@ -993,5 +1017,5 @@ // Frees the memory space pointed to by ptr, which must have been returned by a previous call to malloc(), calloc() - // or realloc(). Otherwise, or if free(ptr) has already been called before, undefined behavior occurs. If ptr is + // or realloc(). Otherwise, or if free(ptr) has already been called before, undefined behaviour occurs. If ptr is // 0p, no operation is performed. void free( void * addr ) { @@ -1015,5 +1039,5 @@ - // Returns the alignment of the allocation. + // Returns the alignment of an allocation. size_t malloc_alignment( void * addr ) { if ( unlikely( addr == 0p ) ) return libAlign(); // minimum alignment @@ -1026,6 +1050,20 @@ } // malloc_alignment - - // Returns true if the allocation is zero filled, i.e., initially allocated by calloc(). + // Set the alignment for an the allocation and return previous alignment or 0 if no alignment. + size_t $malloc_alignment_set( void * addr, size_t alignment ) { + if ( unlikely( addr == 0p ) ) return libAlign(); // minimum alignment + size_t ret; + HeapManager.Storage.Header * header = headerAddr( addr ); + if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ? + ret = header->kind.fake.alignment & -2; // remove flag from old value + header->kind.fake.alignment = alignment | 1; // add flag to new value + } else { + ret = 0; // => no alignment to change + } // if + return ret; + } // $malloc_alignment_set + + + // Returns true if the allocation is zero filled, e.g., allocated by calloc(). bool malloc_zero_fill( void * addr ) { if ( unlikely( addr == 0p ) ) return false; // null allocation is not zero fill @@ -1034,10 +1072,9 @@ header = realHeader( header ); // backup from fake to real header } // if - return (header->kind.real.blockSize & 2) != 0; // zero filled (calloc/cmemalign) ? + return (header->kind.real.blockSize & 2) != 0; // zero filled ? } // malloc_zero_fill - - // Returns number of elements if the allocation is for an array, i.e., by calloc(). - size_t malloc_dimension( void * addr ) { + // Set allocation is zero filled and return previous zero filled. + bool $malloc_zero_fill_set( void * addr ) { if ( unlikely( addr == 0p ) ) return false; // null allocation is not zero fill HeapManager.Storage.Header * header = headerAddr( addr ); @@ -1045,6 +1082,31 @@ header = realHeader( header ); // backup from fake to real header } // if - return header->dimension; // array (calloc/cmemalign) - } // malloc_zero_fill + bool ret = (header->kind.real.blockSize & 2) != 0; // zero filled ? + header->kind.real.blockSize |= 2; // mark as zero filled + return ret; + } // $malloc_zero_fill_set + + + // Returns original total allocation size (not bucket size) => array size is dimension * sizeif(T). + size_t malloc_size( void * addr ) { + if ( unlikely( addr == 0p ) ) return false; // null allocation is not zero fill + HeapManager.Storage.Header * header = headerAddr( addr ); + if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ? + header = realHeader( header ); // backup from fake to real header + } // if + return header->size; + } // malloc_size + + // Set allocation size and return previous size. + size_t $malloc_size_set( void * addr, size_t size ) { + if ( unlikely( addr == 0p ) ) return false; // null allocation is not zero fill + HeapManager.Storage.Header * header = headerAddr( addr ); + if ( (header->kind.fake.alignment & 1) == 1 ) { // fake header ? + header = realHeader( header ); // backup from fake to real header + } // if + size_t ret = header->size; + header->size = size; + return ret; + } // $malloc_size_set @@ -1082,12 +1144,13 @@ - // Adjusts parameters that control the behavior of the memory-allocation functions (see malloc). The param argument + // Adjusts parameters that control the behaviour of the memory-allocation functions (see malloc). The param argument // specifies the parameter to be modified, and value specifies the new value for that parameter. int mallopt( int option, int value ) { choose( option ) { case M_TOP_PAD: - if ( setHeapExpand( value ) ) return 1; + heapExpand = ceiling( value, pageSize ); return 1; case M_MMAP_THRESHOLD: if ( setMmapStart( value ) ) return 1; + break; } // switch return 0; // error, unsupported Index: libcfa/src/interpose.cfa =================================================================== --- libcfa/src/interpose.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/interpose.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -15,4 +15,5 @@ #include // va_start, va_end +#include #include // strlen #include // _exit, getpid Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/iostream.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Mar 11 14:35:35 2020 -// Update Count : 860 +// Last Modified On : Sat May 2 18:30:25 2020 +// Update Count : 1017 // @@ -29,4 +29,6 @@ #include // creal, cimag } // extern "C" + +#include // fms @@ -459,25 +461,39 @@ \ if ( f.base == 'b' || f.base == 'B' ) { /* bespoke binary format */ \ - int bits; \ - if ( f.val == (T){0} ) bits = 1; /* force at least one bit to print */ \ - else bits = sizeof(long long int) * 8 - __builtin_clzll( f.val ); /* position of most significant bit */ \ - bits = bits > sizeof(f.val) * 8 ? sizeof(f.val) * 8 : bits; \ - int spaces = f.wd - bits; /* can be negative */ \ - if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \ - /* printf( "%d %d\n", bits, spaces ); */ \ + int bits = high1( f.val ); /* position of most significant bit */ \ + if ( bits == 0 ) bits = 1; /* 0 value => force one bit to print */ \ + int spaces; \ if ( ! f.flags.left ) { /* right justified ? */ \ /* Note, base prefix then zero padding or spacing then prefix. */ \ - if ( f.flags.pad0 || f.flags.pc ) { \ + if ( f.flags.pc ) { \ + spaces = f.wd - f.pc; \ + if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \ + if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \ if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \ - if ( f.flags.pc ) spaces = f.pc - bits; \ + spaces = f.pc - bits; \ if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \ } else { \ - if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \ - if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \ + spaces = f.wd - bits; \ + if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \ + if ( f.flags.pad0 ) { \ + if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \ + if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \ + } else { \ + if ( spaces > 0 ) fmt( os, "%*s", spaces, " " ); /* space pad */ \ + if ( ! f.flags.nobsdp ) { fmt( os, "0%c", f.base ); } \ + } /* if */ \ } /* if */ \ - } else if ( ! f.flags.nobsdp ) { \ - fmt( os, "0%c", f.base ); \ + } else { \ + if ( ! f.flags.nobsdp ) fmt( os, "0%c", f.base ); \ + if ( f.flags.pc ) { \ + spaces = f.pc - bits; \ + if ( spaces > 0 ) fmt( os, "%0*d", spaces, 0 ); /* zero pad */ \ + spaces = f.wd - f.pc; \ + } else { /* pad0 flag ignored with left flag */ \ + spaces = f.wd - bits; \ + } /* if */ \ + if ( ! f.flags.nobsdp ) { spaces -= 2; } /* base prefix takes space */ \ } /* if */ \ - int shift = (bits - 1) / 4 * 4; /* floor( bits - 1, 4 ) */ \ + int shift = floor( bits - 1, 4 ); \ typeof( f.val ) temp = f.val; \ fmt( os, "%s", shortbin[(temp >> shift) & 0xf] ); \ @@ -565,28 +581,69 @@ fmt2.flags.pad0 = fmt2.flags.nobsdp = true; \ if ( f.base == 'b' | f.base == 'B' ) { \ - if ( f.wd > 64 ) fmt.wd = f.wd - 64; \ - if ( f.flags.pc && f.pc > 64 ) fmt.pc = f.pc - 64; \ - fmt2.wd = 64; \ + if ( fmt.flags.pc && fmt.pc > 64 ) fmt.pc -= 64; else { fmt.flags.pc = false; fmt.pc = 0; } \ + if ( fmt.flags.left ) { \ + fmt.flags.left = false; \ + fmt.wd = 0; \ + /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ + fmt2.flags.left = true; \ + int msigd = high1( msig ); \ + fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ + if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0b base specifier */ \ + if ( (int)fmt2.wd < 64 ) fmt2.wd = 64; /* cast deals with negative value */ \ + fmt2.flags.pc = true; fmt2.pc = 64; \ + } else { \ + if ( fmt.wd > 64 ) fmt.wd -= 64; \ + else fmt.wd = 1; \ + /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ + fmt2.wd = 64; \ + } /* if */ \ + /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ (ostype &)(os | fmt | "" | fmt2); \ } else if ( f.base == 'o' ) { \ + if ( fmt.flags.pc && fmt.pc > 22 ) fmt.pc -= 22; else { fmt.flags.pc = false; fmt.pc = 0; } \ fmt.val = (unsigned long long int)fmt.val >> 2; \ - if ( f.wd > 21 ) fmt.wd = f.wd - 21; \ - if ( f.flags.pc && f.pc > 21 ) fmt.pc = f.pc - 21; \ - fmt2.wd = 1; \ - fmt2.val = ((msig & 0x3) << 1) + 1; \ - (ostype &)(os | fmt | "" | fmt2); \ - sepOff( os ); \ - fmt2.wd = 21; \ - fmt2.val = lsig & 0x7fffffffffffffff; \ + fmt2.val = ((msig & 0x3) << 1) + ((lsig & 0x8000000000000000U) != 0); \ + if ( fmt.flags.left ) { \ + fmt.flags.left = false; \ + fmt.wd = 0; \ + /* printf( "L %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ + (ostype &)(os | fmt | "" | fmt2); \ + sepOff( os ); \ + fmt2.flags.left = true; \ + int msigd = ceiling( high1( fmt.val ), 3 ); \ + fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ + if ( ! fmt.flags.nobsdp ) fmt2.wd -= 1; /* compensate for 0 base specifier */ \ + if ( (int)fmt2.wd < 21 ) fmt2.wd = 21; /* cast deals with negative value */ \ + fmt2.flags.pc = true; fmt2.pc = 21; \ + } else { \ + if ( fmt.wd > 22 ) fmt.wd -= 22; \ + else fmt.wd = 1; \ + /* printf( "R %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ + (ostype &)(os | fmt | "" | fmt2); \ + sepOff( os ); \ + fmt2.wd = 21; \ + } /* if */ \ + fmt2.val = lsig & 0x7fffffffffffffffU; \ + /* printf( "\nC %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ (ostype &)(os | fmt2); \ - } else { \ - if ( f.flags.left ) { \ - if ( f.wd > 16 ) fmt2.wd = f.wd - 16; \ - fmt.wd = 16; \ + } else { /* f.base == 'x' | f.base == 'X' */ \ + if ( fmt.flags.pc && fmt.pc > 16 ) fmt.pc -= 16; else { fmt.flags.pc = false; fmt.pc = 0; } \ + if ( fmt.flags.left ) { \ + fmt.flags.left = false; \ + fmt.wd = 0; \ + /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ + fmt2.flags.left = true; \ + int msigd = high1( msig ); \ + fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \ + if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0x base specifier */ \ + if ( (int)fmt2.wd < 16 ) fmt2.wd = 16; /* cast deals with negative value */ \ + fmt2.flags.pc = true; fmt2.pc = 16; \ } else { \ - if ( f.wd > 16 ) fmt.wd = f.wd - 16; \ - if ( f.flags.pc && f.pc > 16 ) fmt.pc = f.pc - 16; \ + if ( fmt.wd > 16 ) fmt.wd -= 16; \ + else fmt.wd = 1; \ + /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \ fmt2.wd = 16; \ } /* if */ \ + /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \ (ostype &)(os | fmt | "" | fmt2); \ } /* if */ \ Index: libcfa/src/startup.cfa =================================================================== --- libcfa/src/startup.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/startup.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -14,5 +14,6 @@ // -#include // tzset +#include // tzset +#include // setlocale #include "startup.hfa" @@ -21,4 +22,5 @@ void __cfaabi_appready_startup( void ) { tzset(); // initialize time global variables + setlocale(LC_NUMERIC, ""); #ifdef __CFA_DEBUG__ extern void heapAppStart(); Index: libcfa/src/stdhdr/malloc.h =================================================================== --- libcfa/src/stdhdr/malloc.h (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/stdhdr/malloc.h (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -10,6 +10,6 @@ // Created On : Thu Jul 20 15:58:16 2017 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Mar 8 10:01:20 2020 -// Update Count : 11 +// Last Modified On : Thu Apr 16 22:44:06 2020 +// Update Count : 13 // @@ -31,8 +31,10 @@ extern "C" { +void * aalloc( size_t noOfElems, size_t elemSize ); +void * amemalign( size_t alignment, size_t noOfElems, size_t elemSize ); void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); size_t malloc_alignment( void * ); bool malloc_zero_fill( void * ); -size_t malloc_dimension( void * ); +size_t malloc_size( void * ); int malloc_stats_fd( int fd ); } // extern "C" Index: libcfa/src/stdlib.cfa =================================================================== --- libcfa/src/stdlib.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/stdlib.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:10:29 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Mar 31 13:26:46 2020 -// Update Count : 495 +// Last Modified On : Thu Apr 16 22:43:33 2020 +// Update Count : 498 // @@ -37,10 +37,12 @@ } // alloc_set - T * alloc_set( T ptr[], size_t dim, T fill ) { // realloc array with fill + T * alloc_set( T ptr[], size_t dim, T fill ) { // realloc array with fill size_t olen = malloc_usable_size( ptr ); // current allocation void * nptr = (void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc size_t nlen = malloc_usable_size( nptr ); // new allocation if ( nlen > olen ) { // larger ? - for ( i; dim ) { memcpy( &ptr[i], &fill, sizeof(T) ); } // initialize with fill value + for ( i; malloc_size( ptr ) / sizeof(T) ~ dim ) { + memcpy( &ptr[i], &fill, sizeof(T) ); // initialize with fill value + } // for } // if return (T *)nptr; Index: libcfa/src/stdlib.hfa =================================================================== --- libcfa/src/stdlib.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ libcfa/src/stdlib.hfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Apr 1 18:38:41 2020 -// Update Count : 429 +// Last Modified On : Thu Apr 16 22:44:05 2020 +// Update Count : 432 // @@ -25,4 +25,5 @@ void * memalign( size_t align, size_t size ); // malloc.h size_t malloc_usable_size( void * ptr ); // malloc.h + size_t malloc_size( void * addr ); // CFA heap void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap void * memset( void * dest, int fill, size_t size ); // string.h Index: src/CompilationState.cc =================================================================== --- src/CompilationState.cc (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ src/CompilationState.cc (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -27,4 +27,5 @@ nopreludep = false, genproto = false, + deterministic_output = false, nomainp = false, parsep = false, Index: src/CompilationState.h =================================================================== --- src/CompilationState.h (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ src/CompilationState.h (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -28,4 +28,5 @@ nopreludep, genproto, + deterministic_output, nomainp, parsep, Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ src/Parser/parser.yy (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 6 17:26:45 2020 -// Update Count : 4474 +// Last Modified On : Mon Apr 27 12:25:42 2020 +// Update Count : 4483 // @@ -966,7 +966,11 @@ tuple_expression_list: - assignment_expression_opt - | tuple_expression_list ',' assignment_expression_opt + assignment_expression + | '@' // CFA + { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; } + | tuple_expression_list ',' assignment_expression { $$ = (ExpressionNode *)($1->set_last( $3 )); } + | tuple_expression_list ',' '@' + { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; } ; Index: src/ResolvExpr/TypeEnvironment.cc =================================================================== --- src/ResolvExpr/TypeEnvironment.cc (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ src/ResolvExpr/TypeEnvironment.cc (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -20,4 +20,5 @@ #include // for pair, move +#include "CompilationState.h" // for deterministic_output #include "Common/utility.h" // for maybeClone #include "SynTree/Type.h" // for Type, FunctionType, Type::Fora... @@ -106,7 +107,9 @@ void EqvClass::print( std::ostream &os, Indenter indent ) const { - os << "( "; - std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) ); - os << ")"; + if( !deterministic_output ) { + os << "( "; + std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) ); + os << ")"; + } if ( type ) { os << " -> "; @@ -235,5 +238,5 @@ // check safely bindable if ( r.type && occursIn( r.type, s.vars.begin(), s.vars.end(), *this ) ) return false; - + // merge classes in r.vars.insert( s.vars.begin(), s.vars.end() ); Index: src/main.cc =================================================================== --- src/main.cc (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ src/main.cc (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -449,5 +449,5 @@ -static const char optstring[] = ":c:ghlLmNnpP:S:twW:D:"; +static const char optstring[] = ":c:ghlLmNnpdP:S:twW:D:"; enum { PreludeDir = 128 }; @@ -462,4 +462,5 @@ { "no-prelude", no_argument, nullptr, 'n' }, { "prototypes", no_argument, nullptr, 'p' }, + { "deterministic-out", no_argument, nullptr, 'd' }, { "print", required_argument, nullptr, 'P' }, { "prelude-dir", required_argument, nullptr, PreludeDir }, @@ -482,4 +483,5 @@ "do not read prelude", // -n "generate prototypes for prelude functions", // -p + "don't print output that isn't deterministic", // -d "print", // -P " prelude directory for debug/nodebug", // no flag @@ -586,4 +588,7 @@ genproto = true; break; + case 'd': // don't print non-deterministic output + deterministic_output = true; + break; case 'P': // print options for ( int i = 0;; i += 1 ) { Index: tests/.expect/alloc.txt =================================================================== --- tests/.expect/alloc.txt (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/.expect/alloc.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -35,10 +35,4 @@ CFA realloc array alloc, fill 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede -CFA realloc array alloc, 5 -0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede 0xdededede -CFA realloc array alloc, 5 -0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef -CFA realloc array alloc, 5 -0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff C memalign 42 42.5 Index: sts/.expect/bitmanip.x64.txt =================================================================== --- tests/.expect/bitmanip.x64.txt (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ (revision ) @@ -1,71 +1,0 @@ -cl0 -0 8, 1 7, 2 6, 4 5, 8 4, 16 3, 32 2, 64 1, -128 0, -0 8, 1 7, 2 6, 4 5, 8 4, 16 3, 32 2, 64 1, 128 0, -0 16, 1 15, 2 14, 4 13, 8 12, 16 11, 32 10, 64 9, 128 8, 256 7, 512 6, 1024 5, 2048 4, 4096 3, 8192 2, 16384 1, -32768 0, -0 16, 1 15, 2 14, 4 13, 8 12, 16 11, 32 10, 64 9, 128 8, 256 7, 512 6, 1024 5, 2048 4, 4096 3, 8192 2, 16384 1, 32768 0, -0 32, 1 31, 2 30, 4 29, 8 28, 16 27, 32 26, 64 25, 128 24, 256 23, 512 22, 1024 21, 2048 20, 4096 19, 8192 18, 16384 17, 32768 16, 65536 15, 131072 14, 262144 13, 524288 12, 1048576 11, 2097152 10, 4194304 9, 8388608 8, 16777216 7, 33554432 6, 67108864 5, 134217728 4, 268435456 3, 536870912 2, 1073741824 1, -2147483648 0, -0 32, 1 31, 2 30, 4 29, 8 28, 16 27, 32 26, 64 25, 128 24, 256 23, 512 22, 1024 21, 2048 20, 4096 19, 8192 18, 16384 17, 32768 16, 65536 15, 131072 14, 262144 13, 524288 12, 1048576 11, 2097152 10, 4194304 9, 8388608 8, 16777216 7, 33554432 6, 67108864 5, 134217728 4, 268435456 3, 536870912 2, 1073741824 1, 2147483648 0, -0 64, 1 63, 2 62, 4 61, 8 60, 16 59, 32 58, 64 57, 128 56, 256 55, 512 54, 1024 53, 2048 52, 4096 51, 8192 50, 16384 49, 32768 48, 65536 47, 131072 46, 262144 45, 524288 44, 1048576 43, 2097152 42, 4194304 41, 8388608 40, 16777216 39, 33554432 38, 67108864 37, 134217728 36, 268435456 35, 536870912 34, 1073741824 33, 2147483648 32, 4294967296 31, 8589934592 30, 17179869184 29, 34359738368 28, 68719476736 27, 137438953472 26, 274877906944 25, 549755813888 24, 1099511627776 23, 2199023255552 22, 4398046511104 21, 8796093022208 20, 17592186044416 19, 35184372088832 18, 70368744177664 17, 140737488355328 16, 281474976710656 15, 562949953421312 14, 1125899906842624 13, 2251799813685248 12, 4503599627370496 11, 9007199254740992 10, 18014398509481984 9, 36028797018963968 8, 72057594037927936 7, 144115188075855872 6, 288230376151711744 5, 576460752303423488 4, 1152921504606846976 3, 2305843009213693952 2, 4611686018427387904 1, -9223372036854775808 0, -0 64, 1 63, 2 62, 4 61, 8 60, 16 59, 32 58, 64 57, 128 56, 256 55, 512 54, 1024 53, 2048 52, 4096 51, 8192 50, 16384 49, 32768 48, 65536 47, 131072 46, 262144 45, 524288 44, 1048576 43, 2097152 42, 4194304 41, 8388608 40, 16777216 39, 33554432 38, 67108864 37, 134217728 36, 268435456 35, 536870912 34, 1073741824 33, 2147483648 32, 4294967296 31, 8589934592 30, 17179869184 29, 34359738368 28, 68719476736 27, 137438953472 26, 274877906944 25, 549755813888 24, 1099511627776 23, 2199023255552 22, 4398046511104 21, 8796093022208 20, 17592186044416 19, 35184372088832 18, 70368744177664 17, 140737488355328 16, 281474976710656 15, 562949953421312 14, 1125899906842624 13, 2251799813685248 12, 4503599627370496 11, 9007199254740992 10, 18014398509481984 9, 36028797018963968 8, 72057594037927936 7, 144115188075855872 6, 288230376151711744 5, 576460752303423488 4, 1152921504606846976 3, 2305843009213693952 2, 4611686018427387904 1, 9223372036854775808 0, -0 64, 1 63, 2 62, 4 61, 8 60, 16 59, 32 58, 64 57, 128 56, 256 55, 512 54, 1024 53, 2048 52, 4096 51, 8192 50, 16384 49, 32768 48, 65536 47, 131072 46, 262144 45, 524288 44, 1048576 43, 2097152 42, 4194304 41, 8388608 40, 16777216 39, 33554432 38, 67108864 37, 134217728 36, 268435456 35, 536870912 34, 1073741824 33, 2147483648 32, 4294967296 31, 8589934592 30, 17179869184 29, 34359738368 28, 68719476736 27, 137438953472 26, 274877906944 25, 549755813888 24, 1099511627776 23, 2199023255552 22, 4398046511104 21, 8796093022208 20, 17592186044416 19, 35184372088832 18, 70368744177664 17, 140737488355328 16, 281474976710656 15, 562949953421312 14, 1125899906842624 13, 2251799813685248 12, 4503599627370496 11, 9007199254740992 10, 18014398509481984 9, 36028797018963968 8, 72057594037927936 7, 144115188075855872 6, 288230376151711744 5, 576460752303423488 4, 1152921504606846976 3, 2305843009213693952 2, 4611686018427387904 1, -9223372036854775808 0, -0 64, 1 63, 2 62, 4 61, 8 60, 16 59, 32 58, 64 57, 128 56, 256 55, 512 54, 1024 53, 2048 52, 4096 51, 8192 50, 16384 49, 32768 48, 65536 47, 131072 46, 262144 45, 524288 44, 1048576 43, 2097152 42, 4194304 41, 8388608 40, 16777216 39, 33554432 38, 67108864 37, 134217728 36, 268435456 35, 536870912 34, 1073741824 33, 2147483648 32, 4294967296 31, 8589934592 30, 17179869184 29, 34359738368 28, 68719476736 27, 137438953472 26, 274877906944 25, 549755813888 24, 1099511627776 23, 2199023255552 22, 4398046511104 21, 8796093022208 20, 17592186044416 19, 35184372088832 18, 70368744177664 17, 140737488355328 16, 281474976710656 15, 562949953421312 14, 1125899906842624 13, 2251799813685248 12, 4503599627370496 11, 9007199254740992 10, 18014398509481984 9, 36028797018963968 8, 72057594037927936 7, 144115188075855872 6, 288230376151711744 5, 576460752303423488 4, 1152921504606846976 3, 2305843009213693952 2, 4611686018427387904 1, 9223372036854775808 0, - -ct0 -0 8, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, -128 7, -0 8, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, -0 16, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, -32768 15, -0 16, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, -0 32, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, -2147483648 31, -0 32, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, -0 64, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, 4294967296 32, 8589934592 33, 17179869184 34, 34359738368 35, 68719476736 36, 137438953472 37, 274877906944 38, 549755813888 39, 1099511627776 40, 2199023255552 41, 4398046511104 42, 8796093022208 43, 17592186044416 44, 35184372088832 45, 70368744177664 46, 140737488355328 47, 281474976710656 48, 562949953421312 49, 1125899906842624 50, 2251799813685248 51, 4503599627370496 52, 9007199254740992 53, 18014398509481984 54, 36028797018963968 55, 72057594037927936 56, 144115188075855872 57, 288230376151711744 58, 576460752303423488 59, 1152921504606846976 60, 2305843009213693952 61, 4611686018427387904 62, -9223372036854775808 63, -0 64, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, 4294967296 32, 8589934592 33, 17179869184 34, 34359738368 35, 68719476736 36, 137438953472 37, 274877906944 38, 549755813888 39, 1099511627776 40, 2199023255552 41, 4398046511104 42, 8796093022208 43, 17592186044416 44, 35184372088832 45, 70368744177664 46, 140737488355328 47, 281474976710656 48, 562949953421312 49, 1125899906842624 50, 2251799813685248 51, 4503599627370496 52, 9007199254740992 53, 18014398509481984 54, 36028797018963968 55, 72057594037927936 56, 144115188075855872 57, 288230376151711744 58, 576460752303423488 59, 1152921504606846976 60, 2305843009213693952 61, 4611686018427387904 62, 9223372036854775808 63, -0 64, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, 4294967296 32, 8589934592 33, 17179869184 34, 34359738368 35, 68719476736 36, 137438953472 37, 274877906944 38, 549755813888 39, 1099511627776 40, 2199023255552 41, 4398046511104 42, 8796093022208 43, 17592186044416 44, 35184372088832 45, 70368744177664 46, 140737488355328 47, 281474976710656 48, 562949953421312 49, 1125899906842624 50, 2251799813685248 51, 4503599627370496 52, 9007199254740992 53, 18014398509481984 54, 36028797018963968 55, 72057594037927936 56, 144115188075855872 57, 288230376151711744 58, 576460752303423488 59, 1152921504606846976 60, 2305843009213693952 61, 4611686018427387904 62, -9223372036854775808 63, -0 64, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, 4294967296 32, 8589934592 33, 17179869184 34, 34359738368 35, 68719476736 36, 137438953472 37, 274877906944 38, 549755813888 39, 1099511627776 40, 2199023255552 41, 4398046511104 42, 8796093022208 43, 17592186044416 44, 35184372088832 45, 70368744177664 46, 140737488355328 47, 281474976710656 48, 562949953421312 49, 1125899906842624 50, 2251799813685248 51, 4503599627370496 52, 9007199254740992 53, 18014398509481984 54, 36028797018963968 55, 72057594037927936 56, 144115188075855872 57, 288230376151711744 58, 576460752303423488 59, 1152921504606846976 60, 2305843009213693952 61, 4611686018427387904 62, 9223372036854775808 63, - -ca1 -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, -1 8, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, -1 16, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, -1 32, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, 4294967295 32, - -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, 4294967295 32, 8589934591 33, 17179869183 34, 34359738367 35, 68719476735 36, 137438953471 37, 274877906943 38, 549755813887 39, 1099511627775 40, 2199023255551 41, 4398046511103 42, 8796093022207 43, 17592186044415 44, 35184372088831 45, 70368744177663 46, 140737488355327 47, 281474976710655 48, 562949953421311 49, 1125899906842623 50, 2251799813685247 51, 4503599627370495 52, 9007199254740991 53, 18014398509481983 54, 36028797018963967 55, 72057594037927935 56, 144115188075855871 57, 288230376151711743 58, 576460752303423487 59, 1152921504606846975 60, 2305843009213693951 61, 4611686018427387903 62, 9223372036854775807 63, 18446744073709551615 64, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, 4294967295 32, 8589934591 33, 17179869183 34, 34359738367 35, 68719476735 36, 137438953471 37, 274877906943 38, 549755813887 39, 1099511627775 40, 2199023255551 41, 4398046511103 42, 8796093022207 43, 17592186044415 44, 35184372088831 45, 70368744177663 46, 140737488355327 47, 281474976710655 48, 562949953421311 49, 1125899906842623 50, 2251799813685247 51, 4503599627370495 52, 9007199254740991 53, 18014398509481983 54, 36028797018963967 55, 72057594037927935 56, 144115188075855871 57, 288230376151711743 58, 576460752303423487 59, 1152921504606846975 60, 2305843009213693951 61, 4611686018427387903 62, 9223372036854775807 63, -1 64, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, 4294967295 32, 8589934591 33, 17179869183 34, 34359738367 35, 68719476735 36, 137438953471 37, 274877906943 38, 549755813887 39, 1099511627775 40, 2199023255551 41, 4398046511103 42, 8796093022207 43, 17592186044415 44, 35184372088831 45, 70368744177663 46, 140737488355327 47, 281474976710655 48, 562949953421311 49, 1125899906842623 50, 2251799813685247 51, 4503599627370495 52, 9007199254740991 53, 18014398509481983 54, 36028797018963967 55, 72057594037927935 56, 144115188075855871 57, 288230376151711743 58, 576460752303423487 59, 1152921504606846975 60, 2305843009213693951 61, 4611686018427387903 62, 9223372036854775807 63, 18446744073709551615 64, - -ca0 -0 8, 1 7, 3 6, 7 5, 15 4, 31 3, 63 2, 127 1, -1 0, -0 8, 1 7, 3 6, 7 5, 15 4, 31 3, 63 2, 127 1, 255 0, -0 16, 1 15, 3 14, 7 13, 15 12, 31 11, 63 10, 127 9, 255 8, 511 7, 1023 6, 2047 5, 4095 4, 8191 3, 16383 2, 32767 1, -1 0, -0 16, 1 15, 3 14, 7 13, 15 12, 31 11, 63 10, 127 9, 255 8, 511 7, 1023 6, 2047 5, 4095 4, 8191 3, 16383 2, 32767 1, 65535 0, -0 32, 1 31, 3 30, 7 29, 15 28, 31 27, 63 26, 127 25, 255 24, 511 23, 1023 22, 2047 21, 4095 20, 8191 19, 16383 18, 32767 17, 65535 16, 131071 15, 262143 14, 524287 13, 1048575 12, 2097151 11, 4194303 10, 8388607 9, 16777215 8, 33554431 7, 67108863 6, 134217727 5, 268435455 4, 536870911 3, 1073741823 2, 2147483647 1, -1 0, -0 32, 1 31, 3 30, 7 29, 15 28, 31 27, 63 26, 127 25, 255 24, 511 23, 1023 22, 2047 21, 4095 20, 8191 19, 16383 18, 32767 17, 65535 16, 131071 15, 262143 14, 524287 13, 1048575 12, 2097151 11, 4194303 10, 8388607 9, 16777215 8, 33554431 7, 67108863 6, 134217727 5, 268435455 4, 536870911 3, 1073741823 2, 2147483647 1, 4294967295 0, -0 64, 1 63, 3 62, 7 61, 15 60, 31 59, 63 58, 127 57, 255 56, 511 55, 1023 54, 2047 53, 4095 52, 8191 51, 16383 50, 32767 49, 65535 48, 131071 47, 262143 46, 524287 45, 1048575 44, 2097151 43, 4194303 42, 8388607 41, 16777215 40, 33554431 39, 67108863 38, 134217727 37, 268435455 36, 536870911 35, 1073741823 34, 2147483647 33, 4294967295 32, 8589934591 31, 17179869183 30, 34359738367 29, 68719476735 28, 137438953471 27, 274877906943 26, 549755813887 25, 1099511627775 24, 2199023255551 23, 4398046511103 22, 8796093022207 21, 17592186044415 20, 35184372088831 19, 70368744177663 18, 140737488355327 17, 281474976710655 16, 562949953421311 15, 1125899906842623 14, 2251799813685247 13, 4503599627370495 12, 9007199254740991 11, 18014398509481983 10, 36028797018963967 9, 72057594037927935 8, 144115188075855871 7, 288230376151711743 6, 576460752303423487 5, 1152921504606846975 4, 2305843009213693951 3, 4611686018427387903 2, 9223372036854775807 1, -1 0, -0 64, 1 63, 3 62, 7 61, 15 60, 31 59, 63 58, 127 57, 255 56, 511 55, 1023 54, 2047 53, 4095 52, 8191 51, 16383 50, 32767 49, 65535 48, 131071 47, 262143 46, 524287 45, 1048575 44, 2097151 43, 4194303 42, 8388607 41, 16777215 40, 33554431 39, 67108863 38, 134217727 37, 268435455 36, 536870911 35, 1073741823 34, 2147483647 33, 4294967295 32, 8589934591 31, 17179869183 30, 34359738367 29, 68719476735 28, 137438953471 27, 274877906943 26, 549755813887 25, 1099511627775 24, 2199023255551 23, 4398046511103 22, 8796093022207 21, 17592186044415 20, 35184372088831 19, 70368744177663 18, 140737488355327 17, 281474976710655 16, 562949953421311 15, 1125899906842623 14, 2251799813685247 13, 4503599627370495 12, 9007199254740991 11, 18014398509481983 10, 36028797018963967 9, 72057594037927935 8, 144115188075855871 7, 288230376151711743 6, 576460752303423487 5, 1152921504606846975 4, 2305843009213693951 3, 4611686018427387903 2, 9223372036854775807 1, 18446744073709551615 0, -0 64, 1 63, 3 62, 7 61, 15 60, 31 59, 63 58, 127 57, 255 56, 511 55, 1023 54, 2047 53, 4095 52, 8191 51, 16383 50, 32767 49, 65535 48, 131071 47, 262143 46, 524287 45, 1048575 44, 2097151 43, 4194303 42, 8388607 41, 16777215 40, 33554431 39, 67108863 38, 134217727 37, 268435455 36, 536870911 35, 1073741823 34, 2147483647 33, 4294967295 32, 8589934591 31, 17179869183 30, 34359738367 29, 68719476735 28, 137438953471 27, 274877906943 26, 549755813887 25, 1099511627775 24, 2199023255551 23, 4398046511103 22, 8796093022207 21, 17592186044415 20, 35184372088831 19, 70368744177663 18, 140737488355327 17, 281474976710655 16, 562949953421311 15, 1125899906842623 14, 2251799813685247 13, 4503599627370495 12, 9007199254740991 11, 18014398509481983 10, 36028797018963967 9, 72057594037927935 8, 144115188075855871 7, 288230376151711743 6, 576460752303423487 5, 1152921504606846975 4, 2305843009213693951 3, 4611686018427387903 2, 9223372036854775807 1, -1 0, -0 64, 1 63, 3 62, 7 61, 15 60, 31 59, 63 58, 127 57, 255 56, 511 55, 1023 54, 2047 53, 4095 52, 8191 51, 16383 50, 32767 49, 65535 48, 131071 47, 262143 46, 524287 45, 1048575 44, 2097151 43, 4194303 42, 8388607 41, 16777215 40, 33554431 39, 67108863 38, 134217727 37, 268435455 36, 536870911 35, 1073741823 34, 2147483647 33, 4294967295 32, 8589934591 31, 17179869183 30, 34359738367 29, 68719476735 28, 137438953471 27, 274877906943 26, 549755813887 25, 1099511627775 24, 2199023255551 23, 4398046511103 22, 8796093022207 21, 17592186044415 20, 35184372088831 19, 70368744177663 18, 140737488355327 17, 281474976710655 16, 562949953421311 15, 1125899906842623 14, 2251799813685247 13, 4503599627370495 12, 9007199254740991 11, 18014398509481983 10, 36028797018963967 9, 72057594037927935 8, 144115188075855871 7, 288230376151711743 6, 576460752303423487 5, 1152921504606846975 4, 2305843009213693951 3, 4611686018427387903 2, 9223372036854775807 1, 18446744073709551615 0, - -fls -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, -128 8, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, -32768 16, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, -2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, -9223372036854775808 64, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, 9223372036854775808 64, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, -9223372036854775808 64, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, 9223372036854775808 64, - -fms -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, -128 8, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, -32768 16, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, -2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, -9223372036854775808 64, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, 9223372036854775808 64, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, -9223372036854775808 64, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, 9223372036854775808 64, Index: sts/.expect/bitmanip.x86.txt =================================================================== --- tests/.expect/bitmanip.x86.txt (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ (revision ) @@ -1,71 +1,0 @@ -cl0 -0 8, 1 7, 2 6, 4 5, 8 4, 16 3, 32 2, 64 1, -128 0, -0 8, 1 7, 2 6, 4 5, 8 4, 16 3, 32 2, 64 1, 128 0, -0 16, 1 15, 2 14, 4 13, 8 12, 16 11, 32 10, 64 9, 128 8, 256 7, 512 6, 1024 5, 2048 4, 4096 3, 8192 2, 16384 1, -32768 0, -0 16, 1 15, 2 14, 4 13, 8 12, 16 11, 32 10, 64 9, 128 8, 256 7, 512 6, 1024 5, 2048 4, 4096 3, 8192 2, 16384 1, 32768 0, -0 32, 1 31, 2 30, 4 29, 8 28, 16 27, 32 26, 64 25, 128 24, 256 23, 512 22, 1024 21, 2048 20, 4096 19, 8192 18, 16384 17, 32768 16, 65536 15, 131072 14, 262144 13, 524288 12, 1048576 11, 2097152 10, 4194304 9, 8388608 8, 16777216 7, 33554432 6, 67108864 5, 134217728 4, 268435456 3, 536870912 2, 1073741824 1, -2147483648 0, -0 32, 1 31, 2 30, 4 29, 8 28, 16 27, 32 26, 64 25, 128 24, 256 23, 512 22, 1024 21, 2048 20, 4096 19, 8192 18, 16384 17, 32768 16, 65536 15, 131072 14, 262144 13, 524288 12, 1048576 11, 2097152 10, 4194304 9, 8388608 8, 16777216 7, 33554432 6, 67108864 5, 134217728 4, 268435456 3, 536870912 2, 1073741824 1, 2147483648 0, -0 32, 1 31, 2 30, 4 29, 8 28, 16 27, 32 26, 64 25, 128 24, 256 23, 512 22, 1024 21, 2048 20, 4096 19, 8192 18, 16384 17, 32768 16, 65536 15, 131072 14, 262144 13, 524288 12, 1048576 11, 2097152 10, 4194304 9, 8388608 8, 16777216 7, 33554432 6, 67108864 5, 134217728 4, 268435456 3, 536870912 2, 1073741824 1, -2147483648 0, -0 32, 1 31, 2 30, 4 29, 8 28, 16 27, 32 26, 64 25, 128 24, 256 23, 512 22, 1024 21, 2048 20, 4096 19, 8192 18, 16384 17, 32768 16, 65536 15, 131072 14, 262144 13, 524288 12, 1048576 11, 2097152 10, 4194304 9, 8388608 8, 16777216 7, 33554432 6, 67108864 5, 134217728 4, 268435456 3, 536870912 2, 1073741824 1, 2147483648 0, -0 64, 1 63, 2 62, 4 61, 8 60, 16 59, 32 58, 64 57, 128 56, 256 55, 512 54, 1024 53, 2048 52, 4096 51, 8192 50, 16384 49, 32768 48, 65536 47, 131072 46, 262144 45, 524288 44, 1048576 43, 2097152 42, 4194304 41, 8388608 40, 16777216 39, 33554432 38, 67108864 37, 134217728 36, 268435456 35, 536870912 34, 1073741824 33, 2147483648 32, 4294967296 31, 8589934592 30, 17179869184 29, 34359738368 28, 68719476736 27, 137438953472 26, 274877906944 25, 549755813888 24, 1099511627776 23, 2199023255552 22, 4398046511104 21, 8796093022208 20, 17592186044416 19, 35184372088832 18, 70368744177664 17, 140737488355328 16, 281474976710656 15, 562949953421312 14, 1125899906842624 13, 2251799813685248 12, 4503599627370496 11, 9007199254740992 10, 18014398509481984 9, 36028797018963968 8, 72057594037927936 7, 144115188075855872 6, 288230376151711744 5, 576460752303423488 4, 1152921504606846976 3, 2305843009213693952 2, 4611686018427387904 1, -9223372036854775808 0, -0 64, 1 63, 2 62, 4 61, 8 60, 16 59, 32 58, 64 57, 128 56, 256 55, 512 54, 1024 53, 2048 52, 4096 51, 8192 50, 16384 49, 32768 48, 65536 47, 131072 46, 262144 45, 524288 44, 1048576 43, 2097152 42, 4194304 41, 8388608 40, 16777216 39, 33554432 38, 67108864 37, 134217728 36, 268435456 35, 536870912 34, 1073741824 33, 2147483648 32, 4294967296 31, 8589934592 30, 17179869184 29, 34359738368 28, 68719476736 27, 137438953472 26, 274877906944 25, 549755813888 24, 1099511627776 23, 2199023255552 22, 4398046511104 21, 8796093022208 20, 17592186044416 19, 35184372088832 18, 70368744177664 17, 140737488355328 16, 281474976710656 15, 562949953421312 14, 1125899906842624 13, 2251799813685248 12, 4503599627370496 11, 9007199254740992 10, 18014398509481984 9, 36028797018963968 8, 72057594037927936 7, 144115188075855872 6, 288230376151711744 5, 576460752303423488 4, 1152921504606846976 3, 2305843009213693952 2, 4611686018427387904 1, 9223372036854775808 0, - -ct0 -0 8, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, -128 7, -0 8, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, -0 16, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, -32768 15, -0 16, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, -0 32, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, -2147483648 31, -0 32, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, -0 32, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, -2147483648 31, -0 32, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, -0 64, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, 4294967296 32, 8589934592 33, 17179869184 34, 34359738368 35, 68719476736 36, 137438953472 37, 274877906944 38, 549755813888 39, 1099511627776 40, 2199023255552 41, 4398046511104 42, 8796093022208 43, 17592186044416 44, 35184372088832 45, 70368744177664 46, 140737488355328 47, 281474976710656 48, 562949953421312 49, 1125899906842624 50, 2251799813685248 51, 4503599627370496 52, 9007199254740992 53, 18014398509481984 54, 36028797018963968 55, 72057594037927936 56, 144115188075855872 57, 288230376151711744 58, 576460752303423488 59, 1152921504606846976 60, 2305843009213693952 61, 4611686018427387904 62, -9223372036854775808 63, -0 64, 1 0, 2 1, 4 2, 8 3, 16 4, 32 5, 64 6, 128 7, 256 8, 512 9, 1024 10, 2048 11, 4096 12, 8192 13, 16384 14, 32768 15, 65536 16, 131072 17, 262144 18, 524288 19, 1048576 20, 2097152 21, 4194304 22, 8388608 23, 16777216 24, 33554432 25, 67108864 26, 134217728 27, 268435456 28, 536870912 29, 1073741824 30, 2147483648 31, 4294967296 32, 8589934592 33, 17179869184 34, 34359738368 35, 68719476736 36, 137438953472 37, 274877906944 38, 549755813888 39, 1099511627776 40, 2199023255552 41, 4398046511104 42, 8796093022208 43, 17592186044416 44, 35184372088832 45, 70368744177664 46, 140737488355328 47, 281474976710656 48, 562949953421312 49, 1125899906842624 50, 2251799813685248 51, 4503599627370496 52, 9007199254740992 53, 18014398509481984 54, 36028797018963968 55, 72057594037927936 56, 144115188075855872 57, 288230376151711744 58, 576460752303423488 59, 1152921504606846976 60, 2305843009213693952 61, 4611686018427387904 62, 9223372036854775808 63, - -ca1 -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, -1 8, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, -1 16, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, -1 32, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, 4294967295 32, - -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, 4294967295 32, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, 4294967295 32, -0 0, 1 1, 3 2, 7 3, 15 4, 31 5, 63 6, 127 7, 255 8, 511 9, 1023 10, 2047 11, 4095 12, 8191 13, 16383 14, 32767 15, 65535 16, 131071 17, 262143 18, 524287 19, 1048575 20, 2097151 21, 4194303 22, 8388607 23, 16777215 24, 33554431 25, 67108863 26, 134217727 27, 268435455 28, 536870911 29, 1073741823 30, 2147483647 31, 4294967295 32, - -ca0 -0 8, 1 7, 3 6, 7 5, 15 4, 31 3, 63 2, 127 1, -1 0, -0 8, 1 7, 3 6, 7 5, 15 4, 31 3, 63 2, 127 1, 255 0, -0 16, 1 15, 3 14, 7 13, 15 12, 31 11, 63 10, 127 9, 255 8, 511 7, 1023 6, 2047 5, 4095 4, 8191 3, 16383 2, 32767 1, -1 0, -0 16, 1 15, 3 14, 7 13, 15 12, 31 11, 63 10, 127 9, 255 8, 511 7, 1023 6, 2047 5, 4095 4, 8191 3, 16383 2, 32767 1, 65535 0, -0 32, 1 31, 3 30, 7 29, 15 28, 31 27, 63 26, 127 25, 255 24, 511 23, 1023 22, 2047 21, 4095 20, 8191 19, 16383 18, 32767 17, 65535 16, 131071 15, 262143 14, 524287 13, 1048575 12, 2097151 11, 4194303 10, 8388607 9, 16777215 8, 33554431 7, 67108863 6, 134217727 5, 268435455 4, 536870911 3, 1073741823 2, 2147483647 1, -1 0, -0 32, 1 31, 3 30, 7 29, 15 28, 31 27, 63 26, 127 25, 255 24, 511 23, 1023 22, 2047 21, 4095 20, 8191 19, 16383 18, 32767 17, 65535 16, 131071 15, 262143 14, 524287 13, 1048575 12, 2097151 11, 4194303 10, 8388607 9, 16777215 8, 33554431 7, 67108863 6, 134217727 5, 268435455 4, 536870911 3, 1073741823 2, 2147483647 1, 4294967295 0, -0 32, 1 31, 3 30, 7 29, 15 28, 31 27, 63 26, 127 25, 255 24, 511 23, 1023 22, 2047 21, 4095 20, 8191 19, 16383 18, 32767 17, 65535 16, 131071 15, 262143 14, 524287 13, 1048575 12, 2097151 11, 4194303 10, 8388607 9, 16777215 8, 33554431 7, 67108863 6, 134217727 5, 268435455 4, 536870911 3, 1073741823 2, 2147483647 1, -1 0, -0 32, 1 31, 3 30, 7 29, 15 28, 31 27, 63 26, 127 25, 255 24, 511 23, 1023 22, 2047 21, 4095 20, 8191 19, 16383 18, 32767 17, 65535 16, 131071 15, 262143 14, 524287 13, 1048575 12, 2097151 11, 4194303 10, 8388607 9, 16777215 8, 33554431 7, 67108863 6, 134217727 5, 268435455 4, 536870911 3, 1073741823 2, 2147483647 1, 4294967295 0, -0 64, 1 63, 3 62, 7 61, 15 60, 31 59, 63 58, 127 57, 255 56, 511 55, 1023 54, 2047 53, 4095 52, 8191 51, 16383 50, 32767 49, 65535 48, 131071 47, 262143 46, 524287 45, 1048575 44, 2097151 43, 4194303 42, 8388607 41, 16777215 40, 33554431 39, 67108863 38, 134217727 37, 268435455 36, 536870911 35, 1073741823 34, 2147483647 33, 4294967295 32, -0 64, 1 63, 3 62, 7 61, 15 60, 31 59, 63 58, 127 57, 255 56, 511 55, 1023 54, 2047 53, 4095 52, 8191 51, 16383 50, 32767 49, 65535 48, 131071 47, 262143 46, 524287 45, 1048575 44, 2097151 43, 4194303 42, 8388607 41, 16777215 40, 33554431 39, 67108863 38, 134217727 37, 268435455 36, 536870911 35, 1073741823 34, 2147483647 33, 4294967295 32, - -fls -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, -128 8, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, -32768 16, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, -2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, -2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, -9223372036854775808 64, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, 9223372036854775808 64, - -fms -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, -128 8, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, -32768 16, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, -2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, -2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, -9223372036854775808 64, -0 0, 1 1, 2 2, 4 3, 8 4, 16 5, 32 6, 64 7, 128 8, 256 9, 512 10, 1024 11, 2048 12, 4096 13, 8192 14, 16384 15, 32768 16, 65536 17, 131072 18, 262144 19, 524288 20, 1048576 21, 2097152 22, 4194304 23, 8388608 24, 16777216 25, 33554432 26, 67108864 27, 134217728 28, 268435456 29, 536870912 30, 1073741824 31, 2147483648 32, 4294967296 33, 8589934592 34, 17179869184 35, 34359738368 36, 68719476736 37, 137438953472 38, 274877906944 39, 549755813888 40, 1099511627776 41, 2199023255552 42, 4398046511104 43, 8796093022208 44, 17592186044416 45, 35184372088832 46, 70368744177664 47, 140737488355328 48, 281474976710656 49, 562949953421312 50, 1125899906842624 51, 2251799813685248 52, 4503599627370496 53, 9007199254740992 54, 18014398509481984 55, 36028797018963968 56, 72057594037927936 57, 144115188075855872 58, 288230376151711744 59, 576460752303423488 60, 1152921504606846976 61, 2305843009213693952 62, 4611686018427387904 63, 9223372036854775808 64, Index: tests/.expect/bitmanip1.x64.txt =================================================================== --- tests/.expect/bitmanip1.x64.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/.expect/bitmanip1.x64.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1603 @@ +leading0s + +signed char +0b00000000 8 +0b00000001 7 +0b00000010 6 +0b00000100 5 +0b00001000 4 +0b00010000 3 +0b00100000 2 +0b01000000 1 +0b10000000 0 + +unsigned char +0b00000000 8 +0b00000001 7 +0b00000010 6 +0b00000100 5 +0b00001000 4 +0b00010000 3 +0b00100000 2 +0b01000000 1 +0b10000000 0 + +short int +0b0000000000000000 16 +0b0000000000000001 15 +0b0000000000000010 14 +0b0000000000000100 13 +0b0000000000001000 12 +0b0000000000010000 11 +0b0000000000100000 10 +0b0000000001000000 9 +0b0000000010000000 8 +0b0000000100000000 7 +0b0000001000000000 6 +0b0000010000000000 5 +0b0000100000000000 4 +0b0001000000000000 3 +0b0010000000000000 2 +0b0100000000000000 1 +0b1000000000000000 0 + +unsigned short int +0b0000000000000000 16 +0b0000000000000001 15 +0b0000000000000010 14 +0b0000000000000100 13 +0b0000000000001000 12 +0b0000000000010000 11 +0b0000000000100000 10 +0b0000000001000000 9 +0b0000000010000000 8 +0b0000000100000000 7 +0b0000001000000000 6 +0b0000010000000000 5 +0b0000100000000000 4 +0b0001000000000000 3 +0b0010000000000000 2 +0b0100000000000000 1 +0b1000000000000000 0 + +int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000010 30 +0b00000000000000000000000000000100 29 +0b00000000000000000000000000001000 28 +0b00000000000000000000000000010000 27 +0b00000000000000000000000000100000 26 +0b00000000000000000000000001000000 25 +0b00000000000000000000000010000000 24 +0b00000000000000000000000100000000 23 +0b00000000000000000000001000000000 22 +0b00000000000000000000010000000000 21 +0b00000000000000000000100000000000 20 +0b00000000000000000001000000000000 19 +0b00000000000000000010000000000000 18 +0b00000000000000000100000000000000 17 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 15 +0b00000000000000100000000000000000 14 +0b00000000000001000000000000000000 13 +0b00000000000010000000000000000000 12 +0b00000000000100000000000000000000 11 +0b00000000001000000000000000000000 10 +0b00000000010000000000000000000000 9 +0b00000000100000000000000000000000 8 +0b00000001000000000000000000000000 7 +0b00000010000000000000000000000000 6 +0b00000100000000000000000000000000 5 +0b00001000000000000000000000000000 4 +0b00010000000000000000000000000000 3 +0b00100000000000000000000000000000 2 +0b01000000000000000000000000000000 1 +0b10000000000000000000000000000000 0 + +unsigned int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000010 30 +0b00000000000000000000000000000100 29 +0b00000000000000000000000000001000 28 +0b00000000000000000000000000010000 27 +0b00000000000000000000000000100000 26 +0b00000000000000000000000001000000 25 +0b00000000000000000000000010000000 24 +0b00000000000000000000000100000000 23 +0b00000000000000000000001000000000 22 +0b00000000000000000000010000000000 21 +0b00000000000000000000100000000000 20 +0b00000000000000000001000000000000 19 +0b00000000000000000010000000000000 18 +0b00000000000000000100000000000000 17 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 15 +0b00000000000000100000000000000000 14 +0b00000000000001000000000000000000 13 +0b00000000000010000000000000000000 12 +0b00000000000100000000000000000000 11 +0b00000000001000000000000000000000 10 +0b00000000010000000000000000000000 9 +0b00000000100000000000000000000000 8 +0b00000001000000000000000000000000 7 +0b00000010000000000000000000000000 6 +0b00000100000000000000000000000000 5 +0b00001000000000000000000000000000 4 +0b00010000000000000000000000000000 3 +0b00100000000000000000000000000000 2 +0b01000000000000000000000000000000 1 +0b10000000000000000000000000000000 0 + +long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000010 62 +0b0000000000000000000000000000000000000000000000000000000000000100 61 +0b0000000000000000000000000000000000000000000000000000000000001000 60 +0b0000000000000000000000000000000000000000000000000000000000010000 59 +0b0000000000000000000000000000000000000000000000000000000000100000 58 +0b0000000000000000000000000000000000000000000000000000000001000000 57 +0b0000000000000000000000000000000000000000000000000000000010000000 56 +0b0000000000000000000000000000000000000000000000000000000100000000 55 +0b0000000000000000000000000000000000000000000000000000001000000000 54 +0b0000000000000000000000000000000000000000000000000000010000000000 53 +0b0000000000000000000000000000000000000000000000000000100000000000 52 +0b0000000000000000000000000000000000000000000000000001000000000000 51 +0b0000000000000000000000000000000000000000000000000010000000000000 50 +0b0000000000000000000000000000000000000000000000000100000000000000 49 +0b0000000000000000000000000000000000000000000000001000000000000000 48 +0b0000000000000000000000000000000000000000000000010000000000000000 47 +0b0000000000000000000000000000000000000000000000100000000000000000 46 +0b0000000000000000000000000000000000000000000001000000000000000000 45 +0b0000000000000000000000000000000000000000000010000000000000000000 44 +0b0000000000000000000000000000000000000000000100000000000000000000 43 +0b0000000000000000000000000000000000000000001000000000000000000000 42 +0b0000000000000000000000000000000000000000010000000000000000000000 41 +0b0000000000000000000000000000000000000000100000000000000000000000 40 +0b0000000000000000000000000000000000000001000000000000000000000000 39 +0b0000000000000000000000000000000000000010000000000000000000000000 38 +0b0000000000000000000000000000000000000100000000000000000000000000 37 +0b0000000000000000000000000000000000001000000000000000000000000000 36 +0b0000000000000000000000000000000000010000000000000000000000000000 35 +0b0000000000000000000000000000000000100000000000000000000000000000 34 +0b0000000000000000000000000000000001000000000000000000000000000000 33 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 31 +0b0000000000000000000000000000001000000000000000000000000000000000 30 +0b0000000000000000000000000000010000000000000000000000000000000000 29 +0b0000000000000000000000000000100000000000000000000000000000000000 28 +0b0000000000000000000000000001000000000000000000000000000000000000 27 +0b0000000000000000000000000010000000000000000000000000000000000000 26 +0b0000000000000000000000000100000000000000000000000000000000000000 25 +0b0000000000000000000000001000000000000000000000000000000000000000 24 +0b0000000000000000000000010000000000000000000000000000000000000000 23 +0b0000000000000000000000100000000000000000000000000000000000000000 22 +0b0000000000000000000001000000000000000000000000000000000000000000 21 +0b0000000000000000000010000000000000000000000000000000000000000000 20 +0b0000000000000000000100000000000000000000000000000000000000000000 19 +0b0000000000000000001000000000000000000000000000000000000000000000 18 +0b0000000000000000010000000000000000000000000000000000000000000000 17 +0b0000000000000000100000000000000000000000000000000000000000000000 16 +0b0000000000000001000000000000000000000000000000000000000000000000 15 +0b0000000000000010000000000000000000000000000000000000000000000000 14 +0b0000000000000100000000000000000000000000000000000000000000000000 13 +0b0000000000001000000000000000000000000000000000000000000000000000 12 +0b0000000000010000000000000000000000000000000000000000000000000000 11 +0b0000000000100000000000000000000000000000000000000000000000000000 10 +0b0000000001000000000000000000000000000000000000000000000000000000 9 +0b0000000010000000000000000000000000000000000000000000000000000000 8 +0b0000000100000000000000000000000000000000000000000000000000000000 7 +0b0000001000000000000000000000000000000000000000000000000000000000 6 +0b0000010000000000000000000000000000000000000000000000000000000000 5 +0b0000100000000000000000000000000000000000000000000000000000000000 4 +0b0001000000000000000000000000000000000000000000000000000000000000 3 +0b0010000000000000000000000000000000000000000000000000000000000000 2 +0b0100000000000000000000000000000000000000000000000000000000000000 1 +0b1000000000000000000000000000000000000000000000000000000000000000 0 + +unsigned long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000010 62 +0b0000000000000000000000000000000000000000000000000000000000000100 61 +0b0000000000000000000000000000000000000000000000000000000000001000 60 +0b0000000000000000000000000000000000000000000000000000000000010000 59 +0b0000000000000000000000000000000000000000000000000000000000100000 58 +0b0000000000000000000000000000000000000000000000000000000001000000 57 +0b0000000000000000000000000000000000000000000000000000000010000000 56 +0b0000000000000000000000000000000000000000000000000000000100000000 55 +0b0000000000000000000000000000000000000000000000000000001000000000 54 +0b0000000000000000000000000000000000000000000000000000010000000000 53 +0b0000000000000000000000000000000000000000000000000000100000000000 52 +0b0000000000000000000000000000000000000000000000000001000000000000 51 +0b0000000000000000000000000000000000000000000000000010000000000000 50 +0b0000000000000000000000000000000000000000000000000100000000000000 49 +0b0000000000000000000000000000000000000000000000001000000000000000 48 +0b0000000000000000000000000000000000000000000000010000000000000000 47 +0b0000000000000000000000000000000000000000000000100000000000000000 46 +0b0000000000000000000000000000000000000000000001000000000000000000 45 +0b0000000000000000000000000000000000000000000010000000000000000000 44 +0b0000000000000000000000000000000000000000000100000000000000000000 43 +0b0000000000000000000000000000000000000000001000000000000000000000 42 +0b0000000000000000000000000000000000000000010000000000000000000000 41 +0b0000000000000000000000000000000000000000100000000000000000000000 40 +0b0000000000000000000000000000000000000001000000000000000000000000 39 +0b0000000000000000000000000000000000000010000000000000000000000000 38 +0b0000000000000000000000000000000000000100000000000000000000000000 37 +0b0000000000000000000000000000000000001000000000000000000000000000 36 +0b0000000000000000000000000000000000010000000000000000000000000000 35 +0b0000000000000000000000000000000000100000000000000000000000000000 34 +0b0000000000000000000000000000000001000000000000000000000000000000 33 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 31 +0b0000000000000000000000000000001000000000000000000000000000000000 30 +0b0000000000000000000000000000010000000000000000000000000000000000 29 +0b0000000000000000000000000000100000000000000000000000000000000000 28 +0b0000000000000000000000000001000000000000000000000000000000000000 27 +0b0000000000000000000000000010000000000000000000000000000000000000 26 +0b0000000000000000000000000100000000000000000000000000000000000000 25 +0b0000000000000000000000001000000000000000000000000000000000000000 24 +0b0000000000000000000000010000000000000000000000000000000000000000 23 +0b0000000000000000000000100000000000000000000000000000000000000000 22 +0b0000000000000000000001000000000000000000000000000000000000000000 21 +0b0000000000000000000010000000000000000000000000000000000000000000 20 +0b0000000000000000000100000000000000000000000000000000000000000000 19 +0b0000000000000000001000000000000000000000000000000000000000000000 18 +0b0000000000000000010000000000000000000000000000000000000000000000 17 +0b0000000000000000100000000000000000000000000000000000000000000000 16 +0b0000000000000001000000000000000000000000000000000000000000000000 15 +0b0000000000000010000000000000000000000000000000000000000000000000 14 +0b0000000000000100000000000000000000000000000000000000000000000000 13 +0b0000000000001000000000000000000000000000000000000000000000000000 12 +0b0000000000010000000000000000000000000000000000000000000000000000 11 +0b0000000000100000000000000000000000000000000000000000000000000000 10 +0b0000000001000000000000000000000000000000000000000000000000000000 9 +0b0000000010000000000000000000000000000000000000000000000000000000 8 +0b0000000100000000000000000000000000000000000000000000000000000000 7 +0b0000001000000000000000000000000000000000000000000000000000000000 6 +0b0000010000000000000000000000000000000000000000000000000000000000 5 +0b0000100000000000000000000000000000000000000000000000000000000000 4 +0b0001000000000000000000000000000000000000000000000000000000000000 3 +0b0010000000000000000000000000000000000000000000000000000000000000 2 +0b0100000000000000000000000000000000000000000000000000000000000000 1 +0b1000000000000000000000000000000000000000000000000000000000000000 0 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000010 62 +0b0000000000000000000000000000000000000000000000000000000000000100 61 +0b0000000000000000000000000000000000000000000000000000000000001000 60 +0b0000000000000000000000000000000000000000000000000000000000010000 59 +0b0000000000000000000000000000000000000000000000000000000000100000 58 +0b0000000000000000000000000000000000000000000000000000000001000000 57 +0b0000000000000000000000000000000000000000000000000000000010000000 56 +0b0000000000000000000000000000000000000000000000000000000100000000 55 +0b0000000000000000000000000000000000000000000000000000001000000000 54 +0b0000000000000000000000000000000000000000000000000000010000000000 53 +0b0000000000000000000000000000000000000000000000000000100000000000 52 +0b0000000000000000000000000000000000000000000000000001000000000000 51 +0b0000000000000000000000000000000000000000000000000010000000000000 50 +0b0000000000000000000000000000000000000000000000000100000000000000 49 +0b0000000000000000000000000000000000000000000000001000000000000000 48 +0b0000000000000000000000000000000000000000000000010000000000000000 47 +0b0000000000000000000000000000000000000000000000100000000000000000 46 +0b0000000000000000000000000000000000000000000001000000000000000000 45 +0b0000000000000000000000000000000000000000000010000000000000000000 44 +0b0000000000000000000000000000000000000000000100000000000000000000 43 +0b0000000000000000000000000000000000000000001000000000000000000000 42 +0b0000000000000000000000000000000000000000010000000000000000000000 41 +0b0000000000000000000000000000000000000000100000000000000000000000 40 +0b0000000000000000000000000000000000000001000000000000000000000000 39 +0b0000000000000000000000000000000000000010000000000000000000000000 38 +0b0000000000000000000000000000000000000100000000000000000000000000 37 +0b0000000000000000000000000000000000001000000000000000000000000000 36 +0b0000000000000000000000000000000000010000000000000000000000000000 35 +0b0000000000000000000000000000000000100000000000000000000000000000 34 +0b0000000000000000000000000000000001000000000000000000000000000000 33 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 31 +0b0000000000000000000000000000001000000000000000000000000000000000 30 +0b0000000000000000000000000000010000000000000000000000000000000000 29 +0b0000000000000000000000000000100000000000000000000000000000000000 28 +0b0000000000000000000000000001000000000000000000000000000000000000 27 +0b0000000000000000000000000010000000000000000000000000000000000000 26 +0b0000000000000000000000000100000000000000000000000000000000000000 25 +0b0000000000000000000000001000000000000000000000000000000000000000 24 +0b0000000000000000000000010000000000000000000000000000000000000000 23 +0b0000000000000000000000100000000000000000000000000000000000000000 22 +0b0000000000000000000001000000000000000000000000000000000000000000 21 +0b0000000000000000000010000000000000000000000000000000000000000000 20 +0b0000000000000000000100000000000000000000000000000000000000000000 19 +0b0000000000000000001000000000000000000000000000000000000000000000 18 +0b0000000000000000010000000000000000000000000000000000000000000000 17 +0b0000000000000000100000000000000000000000000000000000000000000000 16 +0b0000000000000001000000000000000000000000000000000000000000000000 15 +0b0000000000000010000000000000000000000000000000000000000000000000 14 +0b0000000000000100000000000000000000000000000000000000000000000000 13 +0b0000000000001000000000000000000000000000000000000000000000000000 12 +0b0000000000010000000000000000000000000000000000000000000000000000 11 +0b0000000000100000000000000000000000000000000000000000000000000000 10 +0b0000000001000000000000000000000000000000000000000000000000000000 9 +0b0000000010000000000000000000000000000000000000000000000000000000 8 +0b0000000100000000000000000000000000000000000000000000000000000000 7 +0b0000001000000000000000000000000000000000000000000000000000000000 6 +0b0000010000000000000000000000000000000000000000000000000000000000 5 +0b0000100000000000000000000000000000000000000000000000000000000000 4 +0b0001000000000000000000000000000000000000000000000000000000000000 3 +0b0010000000000000000000000000000000000000000000000000000000000000 2 +0b0100000000000000000000000000000000000000000000000000000000000000 1 +0b1000000000000000000000000000000000000000000000000000000000000000 0 + +0b0000000000000000000000000000000000000000000000000000000000000000 64 +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000010 62 +0b0000000000000000000000000000000000000000000000000000000000000100 61 +0b0000000000000000000000000000000000000000000000000000000000001000 60 +0b0000000000000000000000000000000000000000000000000000000000010000 59 +0b0000000000000000000000000000000000000000000000000000000000100000 58 +0b0000000000000000000000000000000000000000000000000000000001000000 57 +0b0000000000000000000000000000000000000000000000000000000010000000 56 +0b0000000000000000000000000000000000000000000000000000000100000000 55 +0b0000000000000000000000000000000000000000000000000000001000000000 54 +0b0000000000000000000000000000000000000000000000000000010000000000 53 +0b0000000000000000000000000000000000000000000000000000100000000000 52 +0b0000000000000000000000000000000000000000000000000001000000000000 51 +0b0000000000000000000000000000000000000000000000000010000000000000 50 +0b0000000000000000000000000000000000000000000000000100000000000000 49 +0b0000000000000000000000000000000000000000000000001000000000000000 48 +0b0000000000000000000000000000000000000000000000010000000000000000 47 +0b0000000000000000000000000000000000000000000000100000000000000000 46 +0b0000000000000000000000000000000000000000000001000000000000000000 45 +0b0000000000000000000000000000000000000000000010000000000000000000 44 +0b0000000000000000000000000000000000000000000100000000000000000000 43 +0b0000000000000000000000000000000000000000001000000000000000000000 42 +0b0000000000000000000000000000000000000000010000000000000000000000 41 +0b0000000000000000000000000000000000000000100000000000000000000000 40 +0b0000000000000000000000000000000000000001000000000000000000000000 39 +0b0000000000000000000000000000000000000010000000000000000000000000 38 +0b0000000000000000000000000000000000000100000000000000000000000000 37 +0b0000000000000000000000000000000000001000000000000000000000000000 36 +0b0000000000000000000000000000000000010000000000000000000000000000 35 +0b0000000000000000000000000000000000100000000000000000000000000000 34 +0b0000000000000000000000000000000001000000000000000000000000000000 33 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 31 +0b0000000000000000000000000000001000000000000000000000000000000000 30 +0b0000000000000000000000000000010000000000000000000000000000000000 29 +0b0000000000000000000000000000100000000000000000000000000000000000 28 +0b0000000000000000000000000001000000000000000000000000000000000000 27 +0b0000000000000000000000000010000000000000000000000000000000000000 26 +0b0000000000000000000000000100000000000000000000000000000000000000 25 +0b0000000000000000000000001000000000000000000000000000000000000000 24 +0b0000000000000000000000010000000000000000000000000000000000000000 23 +0b0000000000000000000000100000000000000000000000000000000000000000 22 +0b0000000000000000000001000000000000000000000000000000000000000000 21 +0b0000000000000000000010000000000000000000000000000000000000000000 20 +0b0000000000000000000100000000000000000000000000000000000000000000 19 +0b0000000000000000001000000000000000000000000000000000000000000000 18 +0b0000000000000000010000000000000000000000000000000000000000000000 17 +0b0000000000000000100000000000000000000000000000000000000000000000 16 +0b0000000000000001000000000000000000000000000000000000000000000000 15 +0b0000000000000010000000000000000000000000000000000000000000000000 14 +0b0000000000000100000000000000000000000000000000000000000000000000 13 +0b0000000000001000000000000000000000000000000000000000000000000000 12 +0b0000000000010000000000000000000000000000000000000000000000000000 11 +0b0000000000100000000000000000000000000000000000000000000000000000 10 +0b0000000001000000000000000000000000000000000000000000000000000000 9 +0b0000000010000000000000000000000000000000000000000000000000000000 8 +0b0000000100000000000000000000000000000000000000000000000000000000 7 +0b0000001000000000000000000000000000000000000000000000000000000000 6 +0b0000010000000000000000000000000000000000000000000000000000000000 5 +0b0000100000000000000000000000000000000000000000000000000000000000 4 +0b0001000000000000000000000000000000000000000000000000000000000000 3 +0b0010000000000000000000000000000000000000000000000000000000000000 2 +0b0100000000000000000000000000000000000000000000000000000000000000 1 +0b1000000000000000000000000000000000000000000000000000000000000000 0 + + +trailing0s + +signed char +0b00000001 0 +0b00000010 1 +0b00000100 2 +0b00001000 3 +0b00010000 4 +0b00100000 5 +0b01000000 6 +0b10000000 7 +0b00000000 8 + +unsigned char +0b00000001 0 +0b00000010 1 +0b00000100 2 +0b00001000 3 +0b00010000 4 +0b00100000 5 +0b01000000 6 +0b10000000 7 +0b00000000 8 + +short int +0b0000000000000001 0 +0b0000000000000010 1 +0b0000000000000100 2 +0b0000000000001000 3 +0b0000000000010000 4 +0b0000000000100000 5 +0b0000000001000000 6 +0b0000000010000000 7 +0b0000000100000000 8 +0b0000001000000000 9 +0b0000010000000000 10 +0b0000100000000000 11 +0b0001000000000000 12 +0b0010000000000000 13 +0b0100000000000000 14 +0b1000000000000000 15 +0b0000000000000000 16 + +unsigned short int +0b0000000000000001 0 +0b0000000000000010 1 +0b0000000000000100 2 +0b0000000000001000 3 +0b0000000000010000 4 +0b0000000000100000 5 +0b0000000001000000 6 +0b0000000010000000 7 +0b0000000100000000 8 +0b0000001000000000 9 +0b0000010000000000 10 +0b0000100000000000 11 +0b0001000000000000 12 +0b0010000000000000 13 +0b0100000000000000 14 +0b1000000000000000 15 +0b0000000000000000 16 + +int +0b00000000000000000000000000000001 0 +0b00000000000000000000000000000010 1 +0b00000000000000000000000000000100 2 +0b00000000000000000000000000001000 3 +0b00000000000000000000000000010000 4 +0b00000000000000000000000000100000 5 +0b00000000000000000000000001000000 6 +0b00000000000000000000000010000000 7 +0b00000000000000000000000100000000 8 +0b00000000000000000000001000000000 9 +0b00000000000000000000010000000000 10 +0b00000000000000000000100000000000 11 +0b00000000000000000001000000000000 12 +0b00000000000000000010000000000000 13 +0b00000000000000000100000000000000 14 +0b00000000000000001000000000000000 15 +0b00000000000000010000000000000000 16 +0b00000000000000100000000000000000 17 +0b00000000000001000000000000000000 18 +0b00000000000010000000000000000000 19 +0b00000000000100000000000000000000 20 +0b00000000001000000000000000000000 21 +0b00000000010000000000000000000000 22 +0b00000000100000000000000000000000 23 +0b00000001000000000000000000000000 24 +0b00000010000000000000000000000000 25 +0b00000100000000000000000000000000 26 +0b00001000000000000000000000000000 27 +0b00010000000000000000000000000000 28 +0b00100000000000000000000000000000 29 +0b01000000000000000000000000000000 30 +0b10000000000000000000000000000000 31 +0b00000000000000000000000000000000 32 + +unsigned int +0b00000000000000000000000000000001 0 +0b00000000000000000000000000000010 1 +0b00000000000000000000000000000100 2 +0b00000000000000000000000000001000 3 +0b00000000000000000000000000010000 4 +0b00000000000000000000000000100000 5 +0b00000000000000000000000001000000 6 +0b00000000000000000000000010000000 7 +0b00000000000000000000000100000000 8 +0b00000000000000000000001000000000 9 +0b00000000000000000000010000000000 10 +0b00000000000000000000100000000000 11 +0b00000000000000000001000000000000 12 +0b00000000000000000010000000000000 13 +0b00000000000000000100000000000000 14 +0b00000000000000001000000000000000 15 +0b00000000000000010000000000000000 16 +0b00000000000000100000000000000000 17 +0b00000000000001000000000000000000 18 +0b00000000000010000000000000000000 19 +0b00000000000100000000000000000000 20 +0b00000000001000000000000000000000 21 +0b00000000010000000000000000000000 22 +0b00000000100000000000000000000000 23 +0b00000001000000000000000000000000 24 +0b00000010000000000000000000000000 25 +0b00000100000000000000000000000000 26 +0b00001000000000000000000000000000 27 +0b00010000000000000000000000000000 28 +0b00100000000000000000000000000000 29 +0b01000000000000000000000000000000 30 +0b10000000000000000000000000000000 31 +0b00000000000000000000000000000000 32 + +long int +0b0000000000000000000000000000000000000000000000000000000000000001 0 +0b0000000000000000000000000000000000000000000000000000000000000010 1 +0b0000000000000000000000000000000000000000000000000000000000000100 2 +0b0000000000000000000000000000000000000000000000000000000000001000 3 +0b0000000000000000000000000000000000000000000000000000000000010000 4 +0b0000000000000000000000000000000000000000000000000000000000100000 5 +0b0000000000000000000000000000000000000000000000000000000001000000 6 +0b0000000000000000000000000000000000000000000000000000000010000000 7 +0b0000000000000000000000000000000000000000000000000000000100000000 8 +0b0000000000000000000000000000000000000000000000000000001000000000 9 +0b0000000000000000000000000000000000000000000000000000010000000000 10 +0b0000000000000000000000000000000000000000000000000000100000000000 11 +0b0000000000000000000000000000000000000000000000000001000000000000 12 +0b0000000000000000000000000000000000000000000000000010000000000000 13 +0b0000000000000000000000000000000000000000000000000100000000000000 14 +0b0000000000000000000000000000000000000000000000001000000000000000 15 +0b0000000000000000000000000000000000000000000000010000000000000000 16 +0b0000000000000000000000000000000000000000000000100000000000000000 17 +0b0000000000000000000000000000000000000000000001000000000000000000 18 +0b0000000000000000000000000000000000000000000010000000000000000000 19 +0b0000000000000000000000000000000000000000000100000000000000000000 20 +0b0000000000000000000000000000000000000000001000000000000000000000 21 +0b0000000000000000000000000000000000000000010000000000000000000000 22 +0b0000000000000000000000000000000000000000100000000000000000000000 23 +0b0000000000000000000000000000000000000001000000000000000000000000 24 +0b0000000000000000000000000000000000000010000000000000000000000000 25 +0b0000000000000000000000000000000000000100000000000000000000000000 26 +0b0000000000000000000000000000000000001000000000000000000000000000 27 +0b0000000000000000000000000000000000010000000000000000000000000000 28 +0b0000000000000000000000000000000000100000000000000000000000000000 29 +0b0000000000000000000000000000000001000000000000000000000000000000 30 +0b0000000000000000000000000000000010000000000000000000000000000000 31 +0b0000000000000000000000000000000100000000000000000000000000000000 32 +0b0000000000000000000000000000001000000000000000000000000000000000 33 +0b0000000000000000000000000000010000000000000000000000000000000000 34 +0b0000000000000000000000000000100000000000000000000000000000000000 35 +0b0000000000000000000000000001000000000000000000000000000000000000 36 +0b0000000000000000000000000010000000000000000000000000000000000000 37 +0b0000000000000000000000000100000000000000000000000000000000000000 38 +0b0000000000000000000000001000000000000000000000000000000000000000 39 +0b0000000000000000000000010000000000000000000000000000000000000000 40 +0b0000000000000000000000100000000000000000000000000000000000000000 41 +0b0000000000000000000001000000000000000000000000000000000000000000 42 +0b0000000000000000000010000000000000000000000000000000000000000000 43 +0b0000000000000000000100000000000000000000000000000000000000000000 44 +0b0000000000000000001000000000000000000000000000000000000000000000 45 +0b0000000000000000010000000000000000000000000000000000000000000000 46 +0b0000000000000000100000000000000000000000000000000000000000000000 47 +0b0000000000000001000000000000000000000000000000000000000000000000 48 +0b0000000000000010000000000000000000000000000000000000000000000000 49 +0b0000000000000100000000000000000000000000000000000000000000000000 50 +0b0000000000001000000000000000000000000000000000000000000000000000 51 +0b0000000000010000000000000000000000000000000000000000000000000000 52 +0b0000000000100000000000000000000000000000000000000000000000000000 53 +0b0000000001000000000000000000000000000000000000000000000000000000 54 +0b0000000010000000000000000000000000000000000000000000000000000000 55 +0b0000000100000000000000000000000000000000000000000000000000000000 56 +0b0000001000000000000000000000000000000000000000000000000000000000 57 +0b0000010000000000000000000000000000000000000000000000000000000000 58 +0b0000100000000000000000000000000000000000000000000000000000000000 59 +0b0001000000000000000000000000000000000000000000000000000000000000 60 +0b0010000000000000000000000000000000000000000000000000000000000000 61 +0b0100000000000000000000000000000000000000000000000000000000000000 62 +0b1000000000000000000000000000000000000000000000000000000000000000 63 +0b0000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long int +0b0000000000000000000000000000000000000000000000000000000000000001 0 +0b0000000000000000000000000000000000000000000000000000000000000010 1 +0b0000000000000000000000000000000000000000000000000000000000000100 2 +0b0000000000000000000000000000000000000000000000000000000000001000 3 +0b0000000000000000000000000000000000000000000000000000000000010000 4 +0b0000000000000000000000000000000000000000000000000000000000100000 5 +0b0000000000000000000000000000000000000000000000000000000001000000 6 +0b0000000000000000000000000000000000000000000000000000000010000000 7 +0b0000000000000000000000000000000000000000000000000000000100000000 8 +0b0000000000000000000000000000000000000000000000000000001000000000 9 +0b0000000000000000000000000000000000000000000000000000010000000000 10 +0b0000000000000000000000000000000000000000000000000000100000000000 11 +0b0000000000000000000000000000000000000000000000000001000000000000 12 +0b0000000000000000000000000000000000000000000000000010000000000000 13 +0b0000000000000000000000000000000000000000000000000100000000000000 14 +0b0000000000000000000000000000000000000000000000001000000000000000 15 +0b0000000000000000000000000000000000000000000000010000000000000000 16 +0b0000000000000000000000000000000000000000000000100000000000000000 17 +0b0000000000000000000000000000000000000000000001000000000000000000 18 +0b0000000000000000000000000000000000000000000010000000000000000000 19 +0b0000000000000000000000000000000000000000000100000000000000000000 20 +0b0000000000000000000000000000000000000000001000000000000000000000 21 +0b0000000000000000000000000000000000000000010000000000000000000000 22 +0b0000000000000000000000000000000000000000100000000000000000000000 23 +0b0000000000000000000000000000000000000001000000000000000000000000 24 +0b0000000000000000000000000000000000000010000000000000000000000000 25 +0b0000000000000000000000000000000000000100000000000000000000000000 26 +0b0000000000000000000000000000000000001000000000000000000000000000 27 +0b0000000000000000000000000000000000010000000000000000000000000000 28 +0b0000000000000000000000000000000000100000000000000000000000000000 29 +0b0000000000000000000000000000000001000000000000000000000000000000 30 +0b0000000000000000000000000000000010000000000000000000000000000000 31 +0b0000000000000000000000000000000100000000000000000000000000000000 32 +0b0000000000000000000000000000001000000000000000000000000000000000 33 +0b0000000000000000000000000000010000000000000000000000000000000000 34 +0b0000000000000000000000000000100000000000000000000000000000000000 35 +0b0000000000000000000000000001000000000000000000000000000000000000 36 +0b0000000000000000000000000010000000000000000000000000000000000000 37 +0b0000000000000000000000000100000000000000000000000000000000000000 38 +0b0000000000000000000000001000000000000000000000000000000000000000 39 +0b0000000000000000000000010000000000000000000000000000000000000000 40 +0b0000000000000000000000100000000000000000000000000000000000000000 41 +0b0000000000000000000001000000000000000000000000000000000000000000 42 +0b0000000000000000000010000000000000000000000000000000000000000000 43 +0b0000000000000000000100000000000000000000000000000000000000000000 44 +0b0000000000000000001000000000000000000000000000000000000000000000 45 +0b0000000000000000010000000000000000000000000000000000000000000000 46 +0b0000000000000000100000000000000000000000000000000000000000000000 47 +0b0000000000000001000000000000000000000000000000000000000000000000 48 +0b0000000000000010000000000000000000000000000000000000000000000000 49 +0b0000000000000100000000000000000000000000000000000000000000000000 50 +0b0000000000001000000000000000000000000000000000000000000000000000 51 +0b0000000000010000000000000000000000000000000000000000000000000000 52 +0b0000000000100000000000000000000000000000000000000000000000000000 53 +0b0000000001000000000000000000000000000000000000000000000000000000 54 +0b0000000010000000000000000000000000000000000000000000000000000000 55 +0b0000000100000000000000000000000000000000000000000000000000000000 56 +0b0000001000000000000000000000000000000000000000000000000000000000 57 +0b0000010000000000000000000000000000000000000000000000000000000000 58 +0b0000100000000000000000000000000000000000000000000000000000000000 59 +0b0001000000000000000000000000000000000000000000000000000000000000 60 +0b0010000000000000000000000000000000000000000000000000000000000000 61 +0b0100000000000000000000000000000000000000000000000000000000000000 62 +0b1000000000000000000000000000000000000000000000000000000000000000 63 +0b0000000000000000000000000000000000000000000000000000000000000000 64 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000001 0 +0b0000000000000000000000000000000000000000000000000000000000000010 1 +0b0000000000000000000000000000000000000000000000000000000000000100 2 +0b0000000000000000000000000000000000000000000000000000000000001000 3 +0b0000000000000000000000000000000000000000000000000000000000010000 4 +0b0000000000000000000000000000000000000000000000000000000000100000 5 +0b0000000000000000000000000000000000000000000000000000000001000000 6 +0b0000000000000000000000000000000000000000000000000000000010000000 7 +0b0000000000000000000000000000000000000000000000000000000100000000 8 +0b0000000000000000000000000000000000000000000000000000001000000000 9 +0b0000000000000000000000000000000000000000000000000000010000000000 10 +0b0000000000000000000000000000000000000000000000000000100000000000 11 +0b0000000000000000000000000000000000000000000000000001000000000000 12 +0b0000000000000000000000000000000000000000000000000010000000000000 13 +0b0000000000000000000000000000000000000000000000000100000000000000 14 +0b0000000000000000000000000000000000000000000000001000000000000000 15 +0b0000000000000000000000000000000000000000000000010000000000000000 16 +0b0000000000000000000000000000000000000000000000100000000000000000 17 +0b0000000000000000000000000000000000000000000001000000000000000000 18 +0b0000000000000000000000000000000000000000000010000000000000000000 19 +0b0000000000000000000000000000000000000000000100000000000000000000 20 +0b0000000000000000000000000000000000000000001000000000000000000000 21 +0b0000000000000000000000000000000000000000010000000000000000000000 22 +0b0000000000000000000000000000000000000000100000000000000000000000 23 +0b0000000000000000000000000000000000000001000000000000000000000000 24 +0b0000000000000000000000000000000000000010000000000000000000000000 25 +0b0000000000000000000000000000000000000100000000000000000000000000 26 +0b0000000000000000000000000000000000001000000000000000000000000000 27 +0b0000000000000000000000000000000000010000000000000000000000000000 28 +0b0000000000000000000000000000000000100000000000000000000000000000 29 +0b0000000000000000000000000000000001000000000000000000000000000000 30 +0b0000000000000000000000000000000010000000000000000000000000000000 31 +0b0000000000000000000000000000000100000000000000000000000000000000 32 +0b0000000000000000000000000000001000000000000000000000000000000000 33 +0b0000000000000000000000000000010000000000000000000000000000000000 34 +0b0000000000000000000000000000100000000000000000000000000000000000 35 +0b0000000000000000000000000001000000000000000000000000000000000000 36 +0b0000000000000000000000000010000000000000000000000000000000000000 37 +0b0000000000000000000000000100000000000000000000000000000000000000 38 +0b0000000000000000000000001000000000000000000000000000000000000000 39 +0b0000000000000000000000010000000000000000000000000000000000000000 40 +0b0000000000000000000000100000000000000000000000000000000000000000 41 +0b0000000000000000000001000000000000000000000000000000000000000000 42 +0b0000000000000000000010000000000000000000000000000000000000000000 43 +0b0000000000000000000100000000000000000000000000000000000000000000 44 +0b0000000000000000001000000000000000000000000000000000000000000000 45 +0b0000000000000000010000000000000000000000000000000000000000000000 46 +0b0000000000000000100000000000000000000000000000000000000000000000 47 +0b0000000000000001000000000000000000000000000000000000000000000000 48 +0b0000000000000010000000000000000000000000000000000000000000000000 49 +0b0000000000000100000000000000000000000000000000000000000000000000 50 +0b0000000000001000000000000000000000000000000000000000000000000000 51 +0b0000000000010000000000000000000000000000000000000000000000000000 52 +0b0000000000100000000000000000000000000000000000000000000000000000 53 +0b0000000001000000000000000000000000000000000000000000000000000000 54 +0b0000000010000000000000000000000000000000000000000000000000000000 55 +0b0000000100000000000000000000000000000000000000000000000000000000 56 +0b0000001000000000000000000000000000000000000000000000000000000000 57 +0b0000010000000000000000000000000000000000000000000000000000000000 58 +0b0000100000000000000000000000000000000000000000000000000000000000 59 +0b0001000000000000000000000000000000000000000000000000000000000000 60 +0b0010000000000000000000000000000000000000000000000000000000000000 61 +0b0100000000000000000000000000000000000000000000000000000000000000 62 +0b1000000000000000000000000000000000000000000000000000000000000000 63 +0b0000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000001 0 +0b0000000000000000000000000000000000000000000000000000000000000010 1 +0b0000000000000000000000000000000000000000000000000000000000000100 2 +0b0000000000000000000000000000000000000000000000000000000000001000 3 +0b0000000000000000000000000000000000000000000000000000000000010000 4 +0b0000000000000000000000000000000000000000000000000000000000100000 5 +0b0000000000000000000000000000000000000000000000000000000001000000 6 +0b0000000000000000000000000000000000000000000000000000000010000000 7 +0b0000000000000000000000000000000000000000000000000000000100000000 8 +0b0000000000000000000000000000000000000000000000000000001000000000 9 +0b0000000000000000000000000000000000000000000000000000010000000000 10 +0b0000000000000000000000000000000000000000000000000000100000000000 11 +0b0000000000000000000000000000000000000000000000000001000000000000 12 +0b0000000000000000000000000000000000000000000000000010000000000000 13 +0b0000000000000000000000000000000000000000000000000100000000000000 14 +0b0000000000000000000000000000000000000000000000001000000000000000 15 +0b0000000000000000000000000000000000000000000000010000000000000000 16 +0b0000000000000000000000000000000000000000000000100000000000000000 17 +0b0000000000000000000000000000000000000000000001000000000000000000 18 +0b0000000000000000000000000000000000000000000010000000000000000000 19 +0b0000000000000000000000000000000000000000000100000000000000000000 20 +0b0000000000000000000000000000000000000000001000000000000000000000 21 +0b0000000000000000000000000000000000000000010000000000000000000000 22 +0b0000000000000000000000000000000000000000100000000000000000000000 23 +0b0000000000000000000000000000000000000001000000000000000000000000 24 +0b0000000000000000000000000000000000000010000000000000000000000000 25 +0b0000000000000000000000000000000000000100000000000000000000000000 26 +0b0000000000000000000000000000000000001000000000000000000000000000 27 +0b0000000000000000000000000000000000010000000000000000000000000000 28 +0b0000000000000000000000000000000000100000000000000000000000000000 29 +0b0000000000000000000000000000000001000000000000000000000000000000 30 +0b0000000000000000000000000000000010000000000000000000000000000000 31 +0b0000000000000000000000000000000100000000000000000000000000000000 32 +0b0000000000000000000000000000001000000000000000000000000000000000 33 +0b0000000000000000000000000000010000000000000000000000000000000000 34 +0b0000000000000000000000000000100000000000000000000000000000000000 35 +0b0000000000000000000000000001000000000000000000000000000000000000 36 +0b0000000000000000000000000010000000000000000000000000000000000000 37 +0b0000000000000000000000000100000000000000000000000000000000000000 38 +0b0000000000000000000000001000000000000000000000000000000000000000 39 +0b0000000000000000000000010000000000000000000000000000000000000000 40 +0b0000000000000000000000100000000000000000000000000000000000000000 41 +0b0000000000000000000001000000000000000000000000000000000000000000 42 +0b0000000000000000000010000000000000000000000000000000000000000000 43 +0b0000000000000000000100000000000000000000000000000000000000000000 44 +0b0000000000000000001000000000000000000000000000000000000000000000 45 +0b0000000000000000010000000000000000000000000000000000000000000000 46 +0b0000000000000000100000000000000000000000000000000000000000000000 47 +0b0000000000000001000000000000000000000000000000000000000000000000 48 +0b0000000000000010000000000000000000000000000000000000000000000000 49 +0b0000000000000100000000000000000000000000000000000000000000000000 50 +0b0000000000001000000000000000000000000000000000000000000000000000 51 +0b0000000000010000000000000000000000000000000000000000000000000000 52 +0b0000000000100000000000000000000000000000000000000000000000000000 53 +0b0000000001000000000000000000000000000000000000000000000000000000 54 +0b0000000010000000000000000000000000000000000000000000000000000000 55 +0b0000000100000000000000000000000000000000000000000000000000000000 56 +0b0000001000000000000000000000000000000000000000000000000000000000 57 +0b0000010000000000000000000000000000000000000000000000000000000000 58 +0b0000100000000000000000000000000000000000000000000000000000000000 59 +0b0001000000000000000000000000000000000000000000000000000000000000 60 +0b0010000000000000000000000000000000000000000000000000000000000000 61 +0b0100000000000000000000000000000000000000000000000000000000000000 62 +0b1000000000000000000000000000000000000000000000000000000000000000 63 +0b0000000000000000000000000000000000000000000000000000000000000000 64 + + +all0s + +signed char +0b00000000 8 +0b00000001 7 +0b00000011 6 +0b00000111 5 +0b00001111 4 +0b00011111 3 +0b00111111 2 +0b01111111 1 +0b11111111 0 + +unsigned char +0b00000000 8 +0b00000001 7 +0b00000011 6 +0b00000111 5 +0b00001111 4 +0b00011111 3 +0b00111111 2 +0b01111111 1 +0b11111111 0 + +short int +0b0000000000000000 16 +0b0000000000000001 15 +0b0000000000000011 14 +0b0000000000000111 13 +0b0000000000001111 12 +0b0000000000011111 11 +0b0000000000111111 10 +0b0000000001111111 9 +0b0000000011111111 8 +0b0000000111111111 7 +0b0000001111111111 6 +0b0000011111111111 5 +0b0000111111111111 4 +0b0001111111111111 3 +0b0011111111111111 2 +0b0111111111111111 1 +0b1111111111111111 0 + +unsigned short int +0b0000000000000000 16 +0b0000000000000001 15 +0b0000000000000011 14 +0b0000000000000111 13 +0b0000000000001111 12 +0b0000000000011111 11 +0b0000000000111111 10 +0b0000000001111111 9 +0b0000000011111111 8 +0b0000000111111111 7 +0b0000001111111111 6 +0b0000011111111111 5 +0b0000111111111111 4 +0b0001111111111111 3 +0b0011111111111111 2 +0b0111111111111111 1 +0b1111111111111111 0 + +int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000011 30 +0b00000000000000000000000000000111 29 +0b00000000000000000000000000001111 28 +0b00000000000000000000000000011111 27 +0b00000000000000000000000000111111 26 +0b00000000000000000000000001111111 25 +0b00000000000000000000000011111111 24 +0b00000000000000000000000111111111 23 +0b00000000000000000000001111111111 22 +0b00000000000000000000011111111111 21 +0b00000000000000000000111111111111 20 +0b00000000000000000001111111111111 19 +0b00000000000000000011111111111111 18 +0b00000000000000000111111111111111 17 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 15 +0b00000000000000111111111111111111 14 +0b00000000000001111111111111111111 13 +0b00000000000011111111111111111111 12 +0b00000000000111111111111111111111 11 +0b00000000001111111111111111111111 10 +0b00000000011111111111111111111111 9 +0b00000000111111111111111111111111 8 +0b00000001111111111111111111111111 7 +0b00000011111111111111111111111111 6 +0b00000111111111111111111111111111 5 +0b00001111111111111111111111111111 4 +0b00011111111111111111111111111111 3 +0b00111111111111111111111111111111 2 +0b01111111111111111111111111111111 1 +0b11111111111111111111111111111111 0 + +unsigned int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000011 30 +0b00000000000000000000000000000111 29 +0b00000000000000000000000000001111 28 +0b00000000000000000000000000011111 27 +0b00000000000000000000000000111111 26 +0b00000000000000000000000001111111 25 +0b00000000000000000000000011111111 24 +0b00000000000000000000000111111111 23 +0b00000000000000000000001111111111 22 +0b00000000000000000000011111111111 21 +0b00000000000000000000111111111111 20 +0b00000000000000000001111111111111 19 +0b00000000000000000011111111111111 18 +0b00000000000000000111111111111111 17 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 15 +0b00000000000000111111111111111111 14 +0b00000000000001111111111111111111 13 +0b00000000000011111111111111111111 12 +0b00000000000111111111111111111111 11 +0b00000000001111111111111111111111 10 +0b00000000011111111111111111111111 9 +0b00000000111111111111111111111111 8 +0b00000001111111111111111111111111 7 +0b00000011111111111111111111111111 6 +0b00000111111111111111111111111111 5 +0b00001111111111111111111111111111 4 +0b00011111111111111111111111111111 3 +0b00111111111111111111111111111111 2 +0b01111111111111111111111111111111 1 +0b11111111111111111111111111111111 0 + +long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000011 62 +0b0000000000000000000000000000000000000000000000000000000000000111 61 +0b0000000000000000000000000000000000000000000000000000000000001111 60 +0b0000000000000000000000000000000000000000000000000000000000011111 59 +0b0000000000000000000000000000000000000000000000000000000000111111 58 +0b0000000000000000000000000000000000000000000000000000000001111111 57 +0b0000000000000000000000000000000000000000000000000000000011111111 56 +0b0000000000000000000000000000000000000000000000000000000111111111 55 +0b0000000000000000000000000000000000000000000000000000001111111111 54 +0b0000000000000000000000000000000000000000000000000000011111111111 53 +0b0000000000000000000000000000000000000000000000000000111111111111 52 +0b0000000000000000000000000000000000000000000000000001111111111111 51 +0b0000000000000000000000000000000000000000000000000011111111111111 50 +0b0000000000000000000000000000000000000000000000000111111111111111 49 +0b0000000000000000000000000000000000000000000000001111111111111111 48 +0b0000000000000000000000000000000000000000000000011111111111111111 47 +0b0000000000000000000000000000000000000000000000111111111111111111 46 +0b0000000000000000000000000000000000000000000001111111111111111111 45 +0b0000000000000000000000000000000000000000000011111111111111111111 44 +0b0000000000000000000000000000000000000000000111111111111111111111 43 +0b0000000000000000000000000000000000000000001111111111111111111111 42 +0b0000000000000000000000000000000000000000011111111111111111111111 41 +0b0000000000000000000000000000000000000000111111111111111111111111 40 +0b0000000000000000000000000000000000000001111111111111111111111111 39 +0b0000000000000000000000000000000000000011111111111111111111111111 38 +0b0000000000000000000000000000000000000111111111111111111111111111 37 +0b0000000000000000000000000000000000001111111111111111111111111111 36 +0b0000000000000000000000000000000000011111111111111111111111111111 35 +0b0000000000000000000000000000000000111111111111111111111111111111 34 +0b0000000000000000000000000000000001111111111111111111111111111111 33 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 31 +0b0000000000000000000000000000001111111111111111111111111111111111 30 +0b0000000000000000000000000000011111111111111111111111111111111111 29 +0b0000000000000000000000000000111111111111111111111111111111111111 28 +0b0000000000000000000000000001111111111111111111111111111111111111 27 +0b0000000000000000000000000011111111111111111111111111111111111111 26 +0b0000000000000000000000000111111111111111111111111111111111111111 25 +0b0000000000000000000000001111111111111111111111111111111111111111 24 +0b0000000000000000000000011111111111111111111111111111111111111111 23 +0b0000000000000000000000111111111111111111111111111111111111111111 22 +0b0000000000000000000001111111111111111111111111111111111111111111 21 +0b0000000000000000000011111111111111111111111111111111111111111111 20 +0b0000000000000000000111111111111111111111111111111111111111111111 19 +0b0000000000000000001111111111111111111111111111111111111111111111 18 +0b0000000000000000011111111111111111111111111111111111111111111111 17 +0b0000000000000000111111111111111111111111111111111111111111111111 16 +0b0000000000000001111111111111111111111111111111111111111111111111 15 +0b0000000000000011111111111111111111111111111111111111111111111111 14 +0b0000000000000111111111111111111111111111111111111111111111111111 13 +0b0000000000001111111111111111111111111111111111111111111111111111 12 +0b0000000000011111111111111111111111111111111111111111111111111111 11 +0b0000000000111111111111111111111111111111111111111111111111111111 10 +0b0000000001111111111111111111111111111111111111111111111111111111 9 +0b0000000011111111111111111111111111111111111111111111111111111111 8 +0b0000000111111111111111111111111111111111111111111111111111111111 7 +0b0000001111111111111111111111111111111111111111111111111111111111 6 +0b0000011111111111111111111111111111111111111111111111111111111111 5 +0b0000111111111111111111111111111111111111111111111111111111111111 4 +0b0001111111111111111111111111111111111111111111111111111111111111 3 +0b0011111111111111111111111111111111111111111111111111111111111111 2 +0b0111111111111111111111111111111111111111111111111111111111111111 1 +0b1111111111111111111111111111111111111111111111111111111111111111 0 + +unsigned long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000011 62 +0b0000000000000000000000000000000000000000000000000000000000000111 61 +0b0000000000000000000000000000000000000000000000000000000000001111 60 +0b0000000000000000000000000000000000000000000000000000000000011111 59 +0b0000000000000000000000000000000000000000000000000000000000111111 58 +0b0000000000000000000000000000000000000000000000000000000001111111 57 +0b0000000000000000000000000000000000000000000000000000000011111111 56 +0b0000000000000000000000000000000000000000000000000000000111111111 55 +0b0000000000000000000000000000000000000000000000000000001111111111 54 +0b0000000000000000000000000000000000000000000000000000011111111111 53 +0b0000000000000000000000000000000000000000000000000000111111111111 52 +0b0000000000000000000000000000000000000000000000000001111111111111 51 +0b0000000000000000000000000000000000000000000000000011111111111111 50 +0b0000000000000000000000000000000000000000000000000111111111111111 49 +0b0000000000000000000000000000000000000000000000001111111111111111 48 +0b0000000000000000000000000000000000000000000000011111111111111111 47 +0b0000000000000000000000000000000000000000000000111111111111111111 46 +0b0000000000000000000000000000000000000000000001111111111111111111 45 +0b0000000000000000000000000000000000000000000011111111111111111111 44 +0b0000000000000000000000000000000000000000000111111111111111111111 43 +0b0000000000000000000000000000000000000000001111111111111111111111 42 +0b0000000000000000000000000000000000000000011111111111111111111111 41 +0b0000000000000000000000000000000000000000111111111111111111111111 40 +0b0000000000000000000000000000000000000001111111111111111111111111 39 +0b0000000000000000000000000000000000000011111111111111111111111111 38 +0b0000000000000000000000000000000000000111111111111111111111111111 37 +0b0000000000000000000000000000000000001111111111111111111111111111 36 +0b0000000000000000000000000000000000011111111111111111111111111111 35 +0b0000000000000000000000000000000000111111111111111111111111111111 34 +0b0000000000000000000000000000000001111111111111111111111111111111 33 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 31 +0b0000000000000000000000000000001111111111111111111111111111111111 30 +0b0000000000000000000000000000011111111111111111111111111111111111 29 +0b0000000000000000000000000000111111111111111111111111111111111111 28 +0b0000000000000000000000000001111111111111111111111111111111111111 27 +0b0000000000000000000000000011111111111111111111111111111111111111 26 +0b0000000000000000000000000111111111111111111111111111111111111111 25 +0b0000000000000000000000001111111111111111111111111111111111111111 24 +0b0000000000000000000000011111111111111111111111111111111111111111 23 +0b0000000000000000000000111111111111111111111111111111111111111111 22 +0b0000000000000000000001111111111111111111111111111111111111111111 21 +0b0000000000000000000011111111111111111111111111111111111111111111 20 +0b0000000000000000000111111111111111111111111111111111111111111111 19 +0b0000000000000000001111111111111111111111111111111111111111111111 18 +0b0000000000000000011111111111111111111111111111111111111111111111 17 +0b0000000000000000111111111111111111111111111111111111111111111111 16 +0b0000000000000001111111111111111111111111111111111111111111111111 15 +0b0000000000000011111111111111111111111111111111111111111111111111 14 +0b0000000000000111111111111111111111111111111111111111111111111111 13 +0b0000000000001111111111111111111111111111111111111111111111111111 12 +0b0000000000011111111111111111111111111111111111111111111111111111 11 +0b0000000000111111111111111111111111111111111111111111111111111111 10 +0b0000000001111111111111111111111111111111111111111111111111111111 9 +0b0000000011111111111111111111111111111111111111111111111111111111 8 +0b0000000111111111111111111111111111111111111111111111111111111111 7 +0b0000001111111111111111111111111111111111111111111111111111111111 6 +0b0000011111111111111111111111111111111111111111111111111111111111 5 +0b0000111111111111111111111111111111111111111111111111111111111111 4 +0b0001111111111111111111111111111111111111111111111111111111111111 3 +0b0011111111111111111111111111111111111111111111111111111111111111 2 +0b0111111111111111111111111111111111111111111111111111111111111111 1 +0b1111111111111111111111111111111111111111111111111111111111111111 0 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000011 62 +0b0000000000000000000000000000000000000000000000000000000000000111 61 +0b0000000000000000000000000000000000000000000000000000000000001111 60 +0b0000000000000000000000000000000000000000000000000000000000011111 59 +0b0000000000000000000000000000000000000000000000000000000000111111 58 +0b0000000000000000000000000000000000000000000000000000000001111111 57 +0b0000000000000000000000000000000000000000000000000000000011111111 56 +0b0000000000000000000000000000000000000000000000000000000111111111 55 +0b0000000000000000000000000000000000000000000000000000001111111111 54 +0b0000000000000000000000000000000000000000000000000000011111111111 53 +0b0000000000000000000000000000000000000000000000000000111111111111 52 +0b0000000000000000000000000000000000000000000000000001111111111111 51 +0b0000000000000000000000000000000000000000000000000011111111111111 50 +0b0000000000000000000000000000000000000000000000000111111111111111 49 +0b0000000000000000000000000000000000000000000000001111111111111111 48 +0b0000000000000000000000000000000000000000000000011111111111111111 47 +0b0000000000000000000000000000000000000000000000111111111111111111 46 +0b0000000000000000000000000000000000000000000001111111111111111111 45 +0b0000000000000000000000000000000000000000000011111111111111111111 44 +0b0000000000000000000000000000000000000000000111111111111111111111 43 +0b0000000000000000000000000000000000000000001111111111111111111111 42 +0b0000000000000000000000000000000000000000011111111111111111111111 41 +0b0000000000000000000000000000000000000000111111111111111111111111 40 +0b0000000000000000000000000000000000000001111111111111111111111111 39 +0b0000000000000000000000000000000000000011111111111111111111111111 38 +0b0000000000000000000000000000000000000111111111111111111111111111 37 +0b0000000000000000000000000000000000001111111111111111111111111111 36 +0b0000000000000000000000000000000000011111111111111111111111111111 35 +0b0000000000000000000000000000000000111111111111111111111111111111 34 +0b0000000000000000000000000000000001111111111111111111111111111111 33 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 31 +0b0000000000000000000000000000001111111111111111111111111111111111 30 +0b0000000000000000000000000000011111111111111111111111111111111111 29 +0b0000000000000000000000000000111111111111111111111111111111111111 28 +0b0000000000000000000000000001111111111111111111111111111111111111 27 +0b0000000000000000000000000011111111111111111111111111111111111111 26 +0b0000000000000000000000000111111111111111111111111111111111111111 25 +0b0000000000000000000000001111111111111111111111111111111111111111 24 +0b0000000000000000000000011111111111111111111111111111111111111111 23 +0b0000000000000000000000111111111111111111111111111111111111111111 22 +0b0000000000000000000001111111111111111111111111111111111111111111 21 +0b0000000000000000000011111111111111111111111111111111111111111111 20 +0b0000000000000000000111111111111111111111111111111111111111111111 19 +0b0000000000000000001111111111111111111111111111111111111111111111 18 +0b0000000000000000011111111111111111111111111111111111111111111111 17 +0b0000000000000000111111111111111111111111111111111111111111111111 16 +0b0000000000000001111111111111111111111111111111111111111111111111 15 +0b0000000000000011111111111111111111111111111111111111111111111111 14 +0b0000000000000111111111111111111111111111111111111111111111111111 13 +0b0000000000001111111111111111111111111111111111111111111111111111 12 +0b0000000000011111111111111111111111111111111111111111111111111111 11 +0b0000000000111111111111111111111111111111111111111111111111111111 10 +0b0000000001111111111111111111111111111111111111111111111111111111 9 +0b0000000011111111111111111111111111111111111111111111111111111111 8 +0b0000000111111111111111111111111111111111111111111111111111111111 7 +0b0000001111111111111111111111111111111111111111111111111111111111 6 +0b0000011111111111111111111111111111111111111111111111111111111111 5 +0b0000111111111111111111111111111111111111111111111111111111111111 4 +0b0001111111111111111111111111111111111111111111111111111111111111 3 +0b0011111111111111111111111111111111111111111111111111111111111111 2 +0b0111111111111111111111111111111111111111111111111111111111111111 1 +0b1111111111111111111111111111111111111111111111111111111111111111 0 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000011 62 +0b0000000000000000000000000000000000000000000000000000000000000111 61 +0b0000000000000000000000000000000000000000000000000000000000001111 60 +0b0000000000000000000000000000000000000000000000000000000000011111 59 +0b0000000000000000000000000000000000000000000000000000000000111111 58 +0b0000000000000000000000000000000000000000000000000000000001111111 57 +0b0000000000000000000000000000000000000000000000000000000011111111 56 +0b0000000000000000000000000000000000000000000000000000000111111111 55 +0b0000000000000000000000000000000000000000000000000000001111111111 54 +0b0000000000000000000000000000000000000000000000000000011111111111 53 +0b0000000000000000000000000000000000000000000000000000111111111111 52 +0b0000000000000000000000000000000000000000000000000001111111111111 51 +0b0000000000000000000000000000000000000000000000000011111111111111 50 +0b0000000000000000000000000000000000000000000000000111111111111111 49 +0b0000000000000000000000000000000000000000000000001111111111111111 48 +0b0000000000000000000000000000000000000000000000011111111111111111 47 +0b0000000000000000000000000000000000000000000000111111111111111111 46 +0b0000000000000000000000000000000000000000000001111111111111111111 45 +0b0000000000000000000000000000000000000000000011111111111111111111 44 +0b0000000000000000000000000000000000000000000111111111111111111111 43 +0b0000000000000000000000000000000000000000001111111111111111111111 42 +0b0000000000000000000000000000000000000000011111111111111111111111 41 +0b0000000000000000000000000000000000000000111111111111111111111111 40 +0b0000000000000000000000000000000000000001111111111111111111111111 39 +0b0000000000000000000000000000000000000011111111111111111111111111 38 +0b0000000000000000000000000000000000000111111111111111111111111111 37 +0b0000000000000000000000000000000000001111111111111111111111111111 36 +0b0000000000000000000000000000000000011111111111111111111111111111 35 +0b0000000000000000000000000000000000111111111111111111111111111111 34 +0b0000000000000000000000000000000001111111111111111111111111111111 33 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 31 +0b0000000000000000000000000000001111111111111111111111111111111111 30 +0b0000000000000000000000000000011111111111111111111111111111111111 29 +0b0000000000000000000000000000111111111111111111111111111111111111 28 +0b0000000000000000000000000001111111111111111111111111111111111111 27 +0b0000000000000000000000000011111111111111111111111111111111111111 26 +0b0000000000000000000000000111111111111111111111111111111111111111 25 +0b0000000000000000000000001111111111111111111111111111111111111111 24 +0b0000000000000000000000011111111111111111111111111111111111111111 23 +0b0000000000000000000000111111111111111111111111111111111111111111 22 +0b0000000000000000000001111111111111111111111111111111111111111111 21 +0b0000000000000000000011111111111111111111111111111111111111111111 20 +0b0000000000000000000111111111111111111111111111111111111111111111 19 +0b0000000000000000001111111111111111111111111111111111111111111111 18 +0b0000000000000000011111111111111111111111111111111111111111111111 17 +0b0000000000000000111111111111111111111111111111111111111111111111 16 +0b0000000000000001111111111111111111111111111111111111111111111111 15 +0b0000000000000011111111111111111111111111111111111111111111111111 14 +0b0000000000000111111111111111111111111111111111111111111111111111 13 +0b0000000000001111111111111111111111111111111111111111111111111111 12 +0b0000000000011111111111111111111111111111111111111111111111111111 11 +0b0000000000111111111111111111111111111111111111111111111111111111 10 +0b0000000001111111111111111111111111111111111111111111111111111111 9 +0b0000000011111111111111111111111111111111111111111111111111111111 8 +0b0000000111111111111111111111111111111111111111111111111111111111 7 +0b0000001111111111111111111111111111111111111111111111111111111111 6 +0b0000011111111111111111111111111111111111111111111111111111111111 5 +0b0000111111111111111111111111111111111111111111111111111111111111 4 +0b0001111111111111111111111111111111111111111111111111111111111111 3 +0b0011111111111111111111111111111111111111111111111111111111111111 2 +0b0111111111111111111111111111111111111111111111111111111111111111 1 +0b1111111111111111111111111111111111111111111111111111111111111111 0 + + +all1s + +signed char +0b00000000 0 +0b00000001 1 +0b00000011 2 +0b00000111 3 +0b00001111 4 +0b00011111 5 +0b00111111 6 +0b01111111 7 +0b11111111 8 + +unsigned char +0b00000000 0 +0b00000001 1 +0b00000011 2 +0b00000111 3 +0b00001111 4 +0b00011111 5 +0b00111111 6 +0b01111111 7 +0b11111111 8 + +short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000011 2 +0b0000000000000111 3 +0b0000000000001111 4 +0b0000000000011111 5 +0b0000000000111111 6 +0b0000000001111111 7 +0b0000000011111111 8 +0b0000000111111111 9 +0b0000001111111111 10 +0b0000011111111111 11 +0b0000111111111111 12 +0b0001111111111111 13 +0b0011111111111111 14 +0b0111111111111111 15 +0b1111111111111111 16 + +unsigned short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000011 2 +0b0000000000000111 3 +0b0000000000001111 4 +0b0000000000011111 5 +0b0000000000111111 6 +0b0000000001111111 7 +0b0000000011111111 8 +0b0000000111111111 9 +0b0000001111111111 10 +0b0000011111111111 11 +0b0000111111111111 12 +0b0001111111111111 13 +0b0011111111111111 14 +0b0111111111111111 15 +0b1111111111111111 16 + +int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000011 2 +0b00000000000000000000000000000111 3 +0b00000000000000000000000000001111 4 +0b00000000000000000000000000011111 5 +0b00000000000000000000000000111111 6 +0b00000000000000000000000001111111 7 +0b00000000000000000000000011111111 8 +0b00000000000000000000000111111111 9 +0b00000000000000000000001111111111 10 +0b00000000000000000000011111111111 11 +0b00000000000000000000111111111111 12 +0b00000000000000000001111111111111 13 +0b00000000000000000011111111111111 14 +0b00000000000000000111111111111111 15 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 17 +0b00000000000000111111111111111111 18 +0b00000000000001111111111111111111 19 +0b00000000000011111111111111111111 20 +0b00000000000111111111111111111111 21 +0b00000000001111111111111111111111 22 +0b00000000011111111111111111111111 23 +0b00000000111111111111111111111111 24 +0b00000001111111111111111111111111 25 +0b00000011111111111111111111111111 26 +0b00000111111111111111111111111111 27 +0b00001111111111111111111111111111 28 +0b00011111111111111111111111111111 29 +0b00111111111111111111111111111111 30 +0b01111111111111111111111111111111 31 +0b11111111111111111111111111111111 32 + +unsigned int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000011 2 +0b00000000000000000000000000000111 3 +0b00000000000000000000000000001111 4 +0b00000000000000000000000000011111 5 +0b00000000000000000000000000111111 6 +0b00000000000000000000000001111111 7 +0b00000000000000000000000011111111 8 +0b00000000000000000000000111111111 9 +0b00000000000000000000001111111111 10 +0b00000000000000000000011111111111 11 +0b00000000000000000000111111111111 12 +0b00000000000000000001111111111111 13 +0b00000000000000000011111111111111 14 +0b00000000000000000111111111111111 15 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 17 +0b00000000000000111111111111111111 18 +0b00000000000001111111111111111111 19 +0b00000000000011111111111111111111 20 +0b00000000000111111111111111111111 21 +0b00000000001111111111111111111111 22 +0b00000000011111111111111111111111 23 +0b00000000111111111111111111111111 24 +0b00000001111111111111111111111111 25 +0b00000011111111111111111111111111 26 +0b00000111111111111111111111111111 27 +0b00001111111111111111111111111111 28 +0b00011111111111111111111111111111 29 +0b00111111111111111111111111111111 30 +0b01111111111111111111111111111111 31 +0b11111111111111111111111111111111 32 + +long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000011 2 +0b0000000000000000000000000000000000000000000000000000000000000111 3 +0b0000000000000000000000000000000000000000000000000000000000001111 4 +0b0000000000000000000000000000000000000000000000000000000000011111 5 +0b0000000000000000000000000000000000000000000000000000000000111111 6 +0b0000000000000000000000000000000000000000000000000000000001111111 7 +0b0000000000000000000000000000000000000000000000000000000011111111 8 +0b0000000000000000000000000000000000000000000000000000000111111111 9 +0b0000000000000000000000000000000000000000000000000000001111111111 10 +0b0000000000000000000000000000000000000000000000000000011111111111 11 +0b0000000000000000000000000000000000000000000000000000111111111111 12 +0b0000000000000000000000000000000000000000000000000001111111111111 13 +0b0000000000000000000000000000000000000000000000000011111111111111 14 +0b0000000000000000000000000000000000000000000000000111111111111111 15 +0b0000000000000000000000000000000000000000000000001111111111111111 16 +0b0000000000000000000000000000000000000000000000011111111111111111 17 +0b0000000000000000000000000000000000000000000000111111111111111111 18 +0b0000000000000000000000000000000000000000000001111111111111111111 19 +0b0000000000000000000000000000000000000000000011111111111111111111 20 +0b0000000000000000000000000000000000000000000111111111111111111111 21 +0b0000000000000000000000000000000000000000001111111111111111111111 22 +0b0000000000000000000000000000000000000000011111111111111111111111 23 +0b0000000000000000000000000000000000000000111111111111111111111111 24 +0b0000000000000000000000000000000000000001111111111111111111111111 25 +0b0000000000000000000000000000000000000011111111111111111111111111 26 +0b0000000000000000000000000000000000000111111111111111111111111111 27 +0b0000000000000000000000000000000000001111111111111111111111111111 28 +0b0000000000000000000000000000000000011111111111111111111111111111 29 +0b0000000000000000000000000000000000111111111111111111111111111111 30 +0b0000000000000000000000000000000001111111111111111111111111111111 31 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 33 +0b0000000000000000000000000000001111111111111111111111111111111111 34 +0b0000000000000000000000000000011111111111111111111111111111111111 35 +0b0000000000000000000000000000111111111111111111111111111111111111 36 +0b0000000000000000000000000001111111111111111111111111111111111111 37 +0b0000000000000000000000000011111111111111111111111111111111111111 38 +0b0000000000000000000000000111111111111111111111111111111111111111 39 +0b0000000000000000000000001111111111111111111111111111111111111111 40 +0b0000000000000000000000011111111111111111111111111111111111111111 41 +0b0000000000000000000000111111111111111111111111111111111111111111 42 +0b0000000000000000000001111111111111111111111111111111111111111111 43 +0b0000000000000000000011111111111111111111111111111111111111111111 44 +0b0000000000000000000111111111111111111111111111111111111111111111 45 +0b0000000000000000001111111111111111111111111111111111111111111111 46 +0b0000000000000000011111111111111111111111111111111111111111111111 47 +0b0000000000000000111111111111111111111111111111111111111111111111 48 +0b0000000000000001111111111111111111111111111111111111111111111111 49 +0b0000000000000011111111111111111111111111111111111111111111111111 50 +0b0000000000000111111111111111111111111111111111111111111111111111 51 +0b0000000000001111111111111111111111111111111111111111111111111111 52 +0b0000000000011111111111111111111111111111111111111111111111111111 53 +0b0000000000111111111111111111111111111111111111111111111111111111 54 +0b0000000001111111111111111111111111111111111111111111111111111111 55 +0b0000000011111111111111111111111111111111111111111111111111111111 56 +0b0000000111111111111111111111111111111111111111111111111111111111 57 +0b0000001111111111111111111111111111111111111111111111111111111111 58 +0b0000011111111111111111111111111111111111111111111111111111111111 59 +0b0000111111111111111111111111111111111111111111111111111111111111 60 +0b0001111111111111111111111111111111111111111111111111111111111111 61 +0b0011111111111111111111111111111111111111111111111111111111111111 62 +0b0111111111111111111111111111111111111111111111111111111111111111 63 +0b1111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000011 2 +0b0000000000000000000000000000000000000000000000000000000000000111 3 +0b0000000000000000000000000000000000000000000000000000000000001111 4 +0b0000000000000000000000000000000000000000000000000000000000011111 5 +0b0000000000000000000000000000000000000000000000000000000000111111 6 +0b0000000000000000000000000000000000000000000000000000000001111111 7 +0b0000000000000000000000000000000000000000000000000000000011111111 8 +0b0000000000000000000000000000000000000000000000000000000111111111 9 +0b0000000000000000000000000000000000000000000000000000001111111111 10 +0b0000000000000000000000000000000000000000000000000000011111111111 11 +0b0000000000000000000000000000000000000000000000000000111111111111 12 +0b0000000000000000000000000000000000000000000000000001111111111111 13 +0b0000000000000000000000000000000000000000000000000011111111111111 14 +0b0000000000000000000000000000000000000000000000000111111111111111 15 +0b0000000000000000000000000000000000000000000000001111111111111111 16 +0b0000000000000000000000000000000000000000000000011111111111111111 17 +0b0000000000000000000000000000000000000000000000111111111111111111 18 +0b0000000000000000000000000000000000000000000001111111111111111111 19 +0b0000000000000000000000000000000000000000000011111111111111111111 20 +0b0000000000000000000000000000000000000000000111111111111111111111 21 +0b0000000000000000000000000000000000000000001111111111111111111111 22 +0b0000000000000000000000000000000000000000011111111111111111111111 23 +0b0000000000000000000000000000000000000000111111111111111111111111 24 +0b0000000000000000000000000000000000000001111111111111111111111111 25 +0b0000000000000000000000000000000000000011111111111111111111111111 26 +0b0000000000000000000000000000000000000111111111111111111111111111 27 +0b0000000000000000000000000000000000001111111111111111111111111111 28 +0b0000000000000000000000000000000000011111111111111111111111111111 29 +0b0000000000000000000000000000000000111111111111111111111111111111 30 +0b0000000000000000000000000000000001111111111111111111111111111111 31 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 33 +0b0000000000000000000000000000001111111111111111111111111111111111 34 +0b0000000000000000000000000000011111111111111111111111111111111111 35 +0b0000000000000000000000000000111111111111111111111111111111111111 36 +0b0000000000000000000000000001111111111111111111111111111111111111 37 +0b0000000000000000000000000011111111111111111111111111111111111111 38 +0b0000000000000000000000000111111111111111111111111111111111111111 39 +0b0000000000000000000000001111111111111111111111111111111111111111 40 +0b0000000000000000000000011111111111111111111111111111111111111111 41 +0b0000000000000000000000111111111111111111111111111111111111111111 42 +0b0000000000000000000001111111111111111111111111111111111111111111 43 +0b0000000000000000000011111111111111111111111111111111111111111111 44 +0b0000000000000000000111111111111111111111111111111111111111111111 45 +0b0000000000000000001111111111111111111111111111111111111111111111 46 +0b0000000000000000011111111111111111111111111111111111111111111111 47 +0b0000000000000000111111111111111111111111111111111111111111111111 48 +0b0000000000000001111111111111111111111111111111111111111111111111 49 +0b0000000000000011111111111111111111111111111111111111111111111111 50 +0b0000000000000111111111111111111111111111111111111111111111111111 51 +0b0000000000001111111111111111111111111111111111111111111111111111 52 +0b0000000000011111111111111111111111111111111111111111111111111111 53 +0b0000000000111111111111111111111111111111111111111111111111111111 54 +0b0000000001111111111111111111111111111111111111111111111111111111 55 +0b0000000011111111111111111111111111111111111111111111111111111111 56 +0b0000000111111111111111111111111111111111111111111111111111111111 57 +0b0000001111111111111111111111111111111111111111111111111111111111 58 +0b0000011111111111111111111111111111111111111111111111111111111111 59 +0b0000111111111111111111111111111111111111111111111111111111111111 60 +0b0001111111111111111111111111111111111111111111111111111111111111 61 +0b0011111111111111111111111111111111111111111111111111111111111111 62 +0b0111111111111111111111111111111111111111111111111111111111111111 63 +0b1111111111111111111111111111111111111111111111111111111111111111 64 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000011 2 +0b0000000000000000000000000000000000000000000000000000000000000111 3 +0b0000000000000000000000000000000000000000000000000000000000001111 4 +0b0000000000000000000000000000000000000000000000000000000000011111 5 +0b0000000000000000000000000000000000000000000000000000000000111111 6 +0b0000000000000000000000000000000000000000000000000000000001111111 7 +0b0000000000000000000000000000000000000000000000000000000011111111 8 +0b0000000000000000000000000000000000000000000000000000000111111111 9 +0b0000000000000000000000000000000000000000000000000000001111111111 10 +0b0000000000000000000000000000000000000000000000000000011111111111 11 +0b0000000000000000000000000000000000000000000000000000111111111111 12 +0b0000000000000000000000000000000000000000000000000001111111111111 13 +0b0000000000000000000000000000000000000000000000000011111111111111 14 +0b0000000000000000000000000000000000000000000000000111111111111111 15 +0b0000000000000000000000000000000000000000000000001111111111111111 16 +0b0000000000000000000000000000000000000000000000011111111111111111 17 +0b0000000000000000000000000000000000000000000000111111111111111111 18 +0b0000000000000000000000000000000000000000000001111111111111111111 19 +0b0000000000000000000000000000000000000000000011111111111111111111 20 +0b0000000000000000000000000000000000000000000111111111111111111111 21 +0b0000000000000000000000000000000000000000001111111111111111111111 22 +0b0000000000000000000000000000000000000000011111111111111111111111 23 +0b0000000000000000000000000000000000000000111111111111111111111111 24 +0b0000000000000000000000000000000000000001111111111111111111111111 25 +0b0000000000000000000000000000000000000011111111111111111111111111 26 +0b0000000000000000000000000000000000000111111111111111111111111111 27 +0b0000000000000000000000000000000000001111111111111111111111111111 28 +0b0000000000000000000000000000000000011111111111111111111111111111 29 +0b0000000000000000000000000000000000111111111111111111111111111111 30 +0b0000000000000000000000000000000001111111111111111111111111111111 31 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 33 +0b0000000000000000000000000000001111111111111111111111111111111111 34 +0b0000000000000000000000000000011111111111111111111111111111111111 35 +0b0000000000000000000000000000111111111111111111111111111111111111 36 +0b0000000000000000000000000001111111111111111111111111111111111111 37 +0b0000000000000000000000000011111111111111111111111111111111111111 38 +0b0000000000000000000000000111111111111111111111111111111111111111 39 +0b0000000000000000000000001111111111111111111111111111111111111111 40 +0b0000000000000000000000011111111111111111111111111111111111111111 41 +0b0000000000000000000000111111111111111111111111111111111111111111 42 +0b0000000000000000000001111111111111111111111111111111111111111111 43 +0b0000000000000000000011111111111111111111111111111111111111111111 44 +0b0000000000000000000111111111111111111111111111111111111111111111 45 +0b0000000000000000001111111111111111111111111111111111111111111111 46 +0b0000000000000000011111111111111111111111111111111111111111111111 47 +0b0000000000000000111111111111111111111111111111111111111111111111 48 +0b0000000000000001111111111111111111111111111111111111111111111111 49 +0b0000000000000011111111111111111111111111111111111111111111111111 50 +0b0000000000000111111111111111111111111111111111111111111111111111 51 +0b0000000000001111111111111111111111111111111111111111111111111111 52 +0b0000000000011111111111111111111111111111111111111111111111111111 53 +0b0000000000111111111111111111111111111111111111111111111111111111 54 +0b0000000001111111111111111111111111111111111111111111111111111111 55 +0b0000000011111111111111111111111111111111111111111111111111111111 56 +0b0000000111111111111111111111111111111111111111111111111111111111 57 +0b0000001111111111111111111111111111111111111111111111111111111111 58 +0b0000011111111111111111111111111111111111111111111111111111111111 59 +0b0000111111111111111111111111111111111111111111111111111111111111 60 +0b0001111111111111111111111111111111111111111111111111111111111111 61 +0b0011111111111111111111111111111111111111111111111111111111111111 62 +0b0111111111111111111111111111111111111111111111111111111111111111 63 +0b1111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000011 2 +0b0000000000000000000000000000000000000000000000000000000000000111 3 +0b0000000000000000000000000000000000000000000000000000000000001111 4 +0b0000000000000000000000000000000000000000000000000000000000011111 5 +0b0000000000000000000000000000000000000000000000000000000000111111 6 +0b0000000000000000000000000000000000000000000000000000000001111111 7 +0b0000000000000000000000000000000000000000000000000000000011111111 8 +0b0000000000000000000000000000000000000000000000000000000111111111 9 +0b0000000000000000000000000000000000000000000000000000001111111111 10 +0b0000000000000000000000000000000000000000000000000000011111111111 11 +0b0000000000000000000000000000000000000000000000000000111111111111 12 +0b0000000000000000000000000000000000000000000000000001111111111111 13 +0b0000000000000000000000000000000000000000000000000011111111111111 14 +0b0000000000000000000000000000000000000000000000000111111111111111 15 +0b0000000000000000000000000000000000000000000000001111111111111111 16 +0b0000000000000000000000000000000000000000000000011111111111111111 17 +0b0000000000000000000000000000000000000000000000111111111111111111 18 +0b0000000000000000000000000000000000000000000001111111111111111111 19 +0b0000000000000000000000000000000000000000000011111111111111111111 20 +0b0000000000000000000000000000000000000000000111111111111111111111 21 +0b0000000000000000000000000000000000000000001111111111111111111111 22 +0b0000000000000000000000000000000000000000011111111111111111111111 23 +0b0000000000000000000000000000000000000000111111111111111111111111 24 +0b0000000000000000000000000000000000000001111111111111111111111111 25 +0b0000000000000000000000000000000000000011111111111111111111111111 26 +0b0000000000000000000000000000000000000111111111111111111111111111 27 +0b0000000000000000000000000000000000001111111111111111111111111111 28 +0b0000000000000000000000000000000000011111111111111111111111111111 29 +0b0000000000000000000000000000000000111111111111111111111111111111 30 +0b0000000000000000000000000000000001111111111111111111111111111111 31 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 33 +0b0000000000000000000000000000001111111111111111111111111111111111 34 +0b0000000000000000000000000000011111111111111111111111111111111111 35 +0b0000000000000000000000000000111111111111111111111111111111111111 36 +0b0000000000000000000000000001111111111111111111111111111111111111 37 +0b0000000000000000000000000011111111111111111111111111111111111111 38 +0b0000000000000000000000000111111111111111111111111111111111111111 39 +0b0000000000000000000000001111111111111111111111111111111111111111 40 +0b0000000000000000000000011111111111111111111111111111111111111111 41 +0b0000000000000000000000111111111111111111111111111111111111111111 42 +0b0000000000000000000001111111111111111111111111111111111111111111 43 +0b0000000000000000000011111111111111111111111111111111111111111111 44 +0b0000000000000000000111111111111111111111111111111111111111111111 45 +0b0000000000000000001111111111111111111111111111111111111111111111 46 +0b0000000000000000011111111111111111111111111111111111111111111111 47 +0b0000000000000000111111111111111111111111111111111111111111111111 48 +0b0000000000000001111111111111111111111111111111111111111111111111 49 +0b0000000000000011111111111111111111111111111111111111111111111111 50 +0b0000000000000111111111111111111111111111111111111111111111111111 51 +0b0000000000001111111111111111111111111111111111111111111111111111 52 +0b0000000000011111111111111111111111111111111111111111111111111111 53 +0b0000000000111111111111111111111111111111111111111111111111111111 54 +0b0000000001111111111111111111111111111111111111111111111111111111 55 +0b0000000011111111111111111111111111111111111111111111111111111111 56 +0b0000000111111111111111111111111111111111111111111111111111111111 57 +0b0000001111111111111111111111111111111111111111111111111111111111 58 +0b0000011111111111111111111111111111111111111111111111111111111111 59 +0b0000111111111111111111111111111111111111111111111111111111111111 60 +0b0001111111111111111111111111111111111111111111111111111111111111 61 +0b0011111111111111111111111111111111111111111111111111111111111111 62 +0b0111111111111111111111111111111111111111111111111111111111111111 63 +0b1111111111111111111111111111111111111111111111111111111111111111 64 + Index: tests/.expect/bitmanip1.x86.txt =================================================================== --- tests/.expect/bitmanip1.x86.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/.expect/bitmanip1.x86.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1347 @@ +leading0s + +signed char +0b00000000 8 +0b00000001 7 +0b00000010 6 +0b00000100 5 +0b00001000 4 +0b00010000 3 +0b00100000 2 +0b01000000 1 +0b10000000 0 + +unsigned char +0b00000000 8 +0b00000001 7 +0b00000010 6 +0b00000100 5 +0b00001000 4 +0b00010000 3 +0b00100000 2 +0b01000000 1 +0b10000000 0 + +short int +0b0000000000000000 16 +0b0000000000000001 15 +0b0000000000000010 14 +0b0000000000000100 13 +0b0000000000001000 12 +0b0000000000010000 11 +0b0000000000100000 10 +0b0000000001000000 9 +0b0000000010000000 8 +0b0000000100000000 7 +0b0000001000000000 6 +0b0000010000000000 5 +0b0000100000000000 4 +0b0001000000000000 3 +0b0010000000000000 2 +0b0100000000000000 1 +0b1000000000000000 0 + +unsigned short int +0b0000000000000000 16 +0b0000000000000001 15 +0b0000000000000010 14 +0b0000000000000100 13 +0b0000000000001000 12 +0b0000000000010000 11 +0b0000000000100000 10 +0b0000000001000000 9 +0b0000000010000000 8 +0b0000000100000000 7 +0b0000001000000000 6 +0b0000010000000000 5 +0b0000100000000000 4 +0b0001000000000000 3 +0b0010000000000000 2 +0b0100000000000000 1 +0b1000000000000000 0 + +int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000010 30 +0b00000000000000000000000000000100 29 +0b00000000000000000000000000001000 28 +0b00000000000000000000000000010000 27 +0b00000000000000000000000000100000 26 +0b00000000000000000000000001000000 25 +0b00000000000000000000000010000000 24 +0b00000000000000000000000100000000 23 +0b00000000000000000000001000000000 22 +0b00000000000000000000010000000000 21 +0b00000000000000000000100000000000 20 +0b00000000000000000001000000000000 19 +0b00000000000000000010000000000000 18 +0b00000000000000000100000000000000 17 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 15 +0b00000000000000100000000000000000 14 +0b00000000000001000000000000000000 13 +0b00000000000010000000000000000000 12 +0b00000000000100000000000000000000 11 +0b00000000001000000000000000000000 10 +0b00000000010000000000000000000000 9 +0b00000000100000000000000000000000 8 +0b00000001000000000000000000000000 7 +0b00000010000000000000000000000000 6 +0b00000100000000000000000000000000 5 +0b00001000000000000000000000000000 4 +0b00010000000000000000000000000000 3 +0b00100000000000000000000000000000 2 +0b01000000000000000000000000000000 1 +0b10000000000000000000000000000000 0 + +unsigned int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000010 30 +0b00000000000000000000000000000100 29 +0b00000000000000000000000000001000 28 +0b00000000000000000000000000010000 27 +0b00000000000000000000000000100000 26 +0b00000000000000000000000001000000 25 +0b00000000000000000000000010000000 24 +0b00000000000000000000000100000000 23 +0b00000000000000000000001000000000 22 +0b00000000000000000000010000000000 21 +0b00000000000000000000100000000000 20 +0b00000000000000000001000000000000 19 +0b00000000000000000010000000000000 18 +0b00000000000000000100000000000000 17 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 15 +0b00000000000000100000000000000000 14 +0b00000000000001000000000000000000 13 +0b00000000000010000000000000000000 12 +0b00000000000100000000000000000000 11 +0b00000000001000000000000000000000 10 +0b00000000010000000000000000000000 9 +0b00000000100000000000000000000000 8 +0b00000001000000000000000000000000 7 +0b00000010000000000000000000000000 6 +0b00000100000000000000000000000000 5 +0b00001000000000000000000000000000 4 +0b00010000000000000000000000000000 3 +0b00100000000000000000000000000000 2 +0b01000000000000000000000000000000 1 +0b10000000000000000000000000000000 0 + +long int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000010 30 +0b00000000000000000000000000000100 29 +0b00000000000000000000000000001000 28 +0b00000000000000000000000000010000 27 +0b00000000000000000000000000100000 26 +0b00000000000000000000000001000000 25 +0b00000000000000000000000010000000 24 +0b00000000000000000000000100000000 23 +0b00000000000000000000001000000000 22 +0b00000000000000000000010000000000 21 +0b00000000000000000000100000000000 20 +0b00000000000000000001000000000000 19 +0b00000000000000000010000000000000 18 +0b00000000000000000100000000000000 17 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 15 +0b00000000000000100000000000000000 14 +0b00000000000001000000000000000000 13 +0b00000000000010000000000000000000 12 +0b00000000000100000000000000000000 11 +0b00000000001000000000000000000000 10 +0b00000000010000000000000000000000 9 +0b00000000100000000000000000000000 8 +0b00000001000000000000000000000000 7 +0b00000010000000000000000000000000 6 +0b00000100000000000000000000000000 5 +0b00001000000000000000000000000000 4 +0b00010000000000000000000000000000 3 +0b00100000000000000000000000000000 2 +0b01000000000000000000000000000000 1 +0b10000000000000000000000000000000 0 + +unsigned long int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000010 30 +0b00000000000000000000000000000100 29 +0b00000000000000000000000000001000 28 +0b00000000000000000000000000010000 27 +0b00000000000000000000000000100000 26 +0b00000000000000000000000001000000 25 +0b00000000000000000000000010000000 24 +0b00000000000000000000000100000000 23 +0b00000000000000000000001000000000 22 +0b00000000000000000000010000000000 21 +0b00000000000000000000100000000000 20 +0b00000000000000000001000000000000 19 +0b00000000000000000010000000000000 18 +0b00000000000000000100000000000000 17 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 15 +0b00000000000000100000000000000000 14 +0b00000000000001000000000000000000 13 +0b00000000000010000000000000000000 12 +0b00000000000100000000000000000000 11 +0b00000000001000000000000000000000 10 +0b00000000010000000000000000000000 9 +0b00000000100000000000000000000000 8 +0b00000001000000000000000000000000 7 +0b00000010000000000000000000000000 6 +0b00000100000000000000000000000000 5 +0b00001000000000000000000000000000 4 +0b00010000000000000000000000000000 3 +0b00100000000000000000000000000000 2 +0b01000000000000000000000000000000 1 +0b10000000000000000000000000000000 0 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000010 62 +0b0000000000000000000000000000000000000000000000000000000000000100 61 +0b0000000000000000000000000000000000000000000000000000000000001000 60 +0b0000000000000000000000000000000000000000000000000000000000010000 59 +0b0000000000000000000000000000000000000000000000000000000000100000 58 +0b0000000000000000000000000000000000000000000000000000000001000000 57 +0b0000000000000000000000000000000000000000000000000000000010000000 56 +0b0000000000000000000000000000000000000000000000000000000100000000 55 +0b0000000000000000000000000000000000000000000000000000001000000000 54 +0b0000000000000000000000000000000000000000000000000000010000000000 53 +0b0000000000000000000000000000000000000000000000000000100000000000 52 +0b0000000000000000000000000000000000000000000000000001000000000000 51 +0b0000000000000000000000000000000000000000000000000010000000000000 50 +0b0000000000000000000000000000000000000000000000000100000000000000 49 +0b0000000000000000000000000000000000000000000000001000000000000000 48 +0b0000000000000000000000000000000000000000000000010000000000000000 47 +0b0000000000000000000000000000000000000000000000100000000000000000 46 +0b0000000000000000000000000000000000000000000001000000000000000000 45 +0b0000000000000000000000000000000000000000000010000000000000000000 44 +0b0000000000000000000000000000000000000000000100000000000000000000 43 +0b0000000000000000000000000000000000000000001000000000000000000000 42 +0b0000000000000000000000000000000000000000010000000000000000000000 41 +0b0000000000000000000000000000000000000000100000000000000000000000 40 +0b0000000000000000000000000000000000000001000000000000000000000000 39 +0b0000000000000000000000000000000000000010000000000000000000000000 38 +0b0000000000000000000000000000000000000100000000000000000000000000 37 +0b0000000000000000000000000000000000001000000000000000000000000000 36 +0b0000000000000000000000000000000000010000000000000000000000000000 35 +0b0000000000000000000000000000000000100000000000000000000000000000 34 +0b0000000000000000000000000000000001000000000000000000000000000000 33 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 31 +0b0000000000000000000000000000001000000000000000000000000000000000 30 +0b0000000000000000000000000000010000000000000000000000000000000000 29 +0b0000000000000000000000000000100000000000000000000000000000000000 28 +0b0000000000000000000000000001000000000000000000000000000000000000 27 +0b0000000000000000000000000010000000000000000000000000000000000000 26 +0b0000000000000000000000000100000000000000000000000000000000000000 25 +0b0000000000000000000000001000000000000000000000000000000000000000 24 +0b0000000000000000000000010000000000000000000000000000000000000000 23 +0b0000000000000000000000100000000000000000000000000000000000000000 22 +0b0000000000000000000001000000000000000000000000000000000000000000 21 +0b0000000000000000000010000000000000000000000000000000000000000000 20 +0b0000000000000000000100000000000000000000000000000000000000000000 19 +0b0000000000000000001000000000000000000000000000000000000000000000 18 +0b0000000000000000010000000000000000000000000000000000000000000000 17 +0b0000000000000000100000000000000000000000000000000000000000000000 16 +0b0000000000000001000000000000000000000000000000000000000000000000 15 +0b0000000000000010000000000000000000000000000000000000000000000000 14 +0b0000000000000100000000000000000000000000000000000000000000000000 13 +0b0000000000001000000000000000000000000000000000000000000000000000 12 +0b0000000000010000000000000000000000000000000000000000000000000000 11 +0b0000000000100000000000000000000000000000000000000000000000000000 10 +0b0000000001000000000000000000000000000000000000000000000000000000 9 +0b0000000010000000000000000000000000000000000000000000000000000000 8 +0b0000000100000000000000000000000000000000000000000000000000000000 7 +0b0000001000000000000000000000000000000000000000000000000000000000 6 +0b0000010000000000000000000000000000000000000000000000000000000000 5 +0b0000100000000000000000000000000000000000000000000000000000000000 4 +0b0001000000000000000000000000000000000000000000000000000000000000 3 +0b0010000000000000000000000000000000000000000000000000000000000000 2 +0b0100000000000000000000000000000000000000000000000000000000000000 1 +0b1000000000000000000000000000000000000000000000000000000000000000 0 + +0b0000000000000000000000000000000000000000000000000000000000000000 64 +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000010 62 +0b0000000000000000000000000000000000000000000000000000000000000100 61 +0b0000000000000000000000000000000000000000000000000000000000001000 60 +0b0000000000000000000000000000000000000000000000000000000000010000 59 +0b0000000000000000000000000000000000000000000000000000000000100000 58 +0b0000000000000000000000000000000000000000000000000000000001000000 57 +0b0000000000000000000000000000000000000000000000000000000010000000 56 +0b0000000000000000000000000000000000000000000000000000000100000000 55 +0b0000000000000000000000000000000000000000000000000000001000000000 54 +0b0000000000000000000000000000000000000000000000000000010000000000 53 +0b0000000000000000000000000000000000000000000000000000100000000000 52 +0b0000000000000000000000000000000000000000000000000001000000000000 51 +0b0000000000000000000000000000000000000000000000000010000000000000 50 +0b0000000000000000000000000000000000000000000000000100000000000000 49 +0b0000000000000000000000000000000000000000000000001000000000000000 48 +0b0000000000000000000000000000000000000000000000010000000000000000 47 +0b0000000000000000000000000000000000000000000000100000000000000000 46 +0b0000000000000000000000000000000000000000000001000000000000000000 45 +0b0000000000000000000000000000000000000000000010000000000000000000 44 +0b0000000000000000000000000000000000000000000100000000000000000000 43 +0b0000000000000000000000000000000000000000001000000000000000000000 42 +0b0000000000000000000000000000000000000000010000000000000000000000 41 +0b0000000000000000000000000000000000000000100000000000000000000000 40 +0b0000000000000000000000000000000000000001000000000000000000000000 39 +0b0000000000000000000000000000000000000010000000000000000000000000 38 +0b0000000000000000000000000000000000000100000000000000000000000000 37 +0b0000000000000000000000000000000000001000000000000000000000000000 36 +0b0000000000000000000000000000000000010000000000000000000000000000 35 +0b0000000000000000000000000000000000100000000000000000000000000000 34 +0b0000000000000000000000000000000001000000000000000000000000000000 33 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 31 +0b0000000000000000000000000000001000000000000000000000000000000000 30 +0b0000000000000000000000000000010000000000000000000000000000000000 29 +0b0000000000000000000000000000100000000000000000000000000000000000 28 +0b0000000000000000000000000001000000000000000000000000000000000000 27 +0b0000000000000000000000000010000000000000000000000000000000000000 26 +0b0000000000000000000000000100000000000000000000000000000000000000 25 +0b0000000000000000000000001000000000000000000000000000000000000000 24 +0b0000000000000000000000010000000000000000000000000000000000000000 23 +0b0000000000000000000000100000000000000000000000000000000000000000 22 +0b0000000000000000000001000000000000000000000000000000000000000000 21 +0b0000000000000000000010000000000000000000000000000000000000000000 20 +0b0000000000000000000100000000000000000000000000000000000000000000 19 +0b0000000000000000001000000000000000000000000000000000000000000000 18 +0b0000000000000000010000000000000000000000000000000000000000000000 17 +0b0000000000000000100000000000000000000000000000000000000000000000 16 +0b0000000000000001000000000000000000000000000000000000000000000000 15 +0b0000000000000010000000000000000000000000000000000000000000000000 14 +0b0000000000000100000000000000000000000000000000000000000000000000 13 +0b0000000000001000000000000000000000000000000000000000000000000000 12 +0b0000000000010000000000000000000000000000000000000000000000000000 11 +0b0000000000100000000000000000000000000000000000000000000000000000 10 +0b0000000001000000000000000000000000000000000000000000000000000000 9 +0b0000000010000000000000000000000000000000000000000000000000000000 8 +0b0000000100000000000000000000000000000000000000000000000000000000 7 +0b0000001000000000000000000000000000000000000000000000000000000000 6 +0b0000010000000000000000000000000000000000000000000000000000000000 5 +0b0000100000000000000000000000000000000000000000000000000000000000 4 +0b0001000000000000000000000000000000000000000000000000000000000000 3 +0b0010000000000000000000000000000000000000000000000000000000000000 2 +0b0100000000000000000000000000000000000000000000000000000000000000 1 +0b1000000000000000000000000000000000000000000000000000000000000000 0 + + +trailing0s + +signed char +0b00000001 0 +0b00000010 1 +0b00000100 2 +0b00001000 3 +0b00010000 4 +0b00100000 5 +0b01000000 6 +0b10000000 7 +0b00000000 8 + +unsigned char +0b00000001 0 +0b00000010 1 +0b00000100 2 +0b00001000 3 +0b00010000 4 +0b00100000 5 +0b01000000 6 +0b10000000 7 +0b00000000 8 + +short int +0b0000000000000001 0 +0b0000000000000010 1 +0b0000000000000100 2 +0b0000000000001000 3 +0b0000000000010000 4 +0b0000000000100000 5 +0b0000000001000000 6 +0b0000000010000000 7 +0b0000000100000000 8 +0b0000001000000000 9 +0b0000010000000000 10 +0b0000100000000000 11 +0b0001000000000000 12 +0b0010000000000000 13 +0b0100000000000000 14 +0b1000000000000000 15 +0b0000000000000000 16 + +unsigned short int +0b0000000000000001 0 +0b0000000000000010 1 +0b0000000000000100 2 +0b0000000000001000 3 +0b0000000000010000 4 +0b0000000000100000 5 +0b0000000001000000 6 +0b0000000010000000 7 +0b0000000100000000 8 +0b0000001000000000 9 +0b0000010000000000 10 +0b0000100000000000 11 +0b0001000000000000 12 +0b0010000000000000 13 +0b0100000000000000 14 +0b1000000000000000 15 +0b0000000000000000 16 + +int +0b00000000000000000000000000000001 0 +0b00000000000000000000000000000010 1 +0b00000000000000000000000000000100 2 +0b00000000000000000000000000001000 3 +0b00000000000000000000000000010000 4 +0b00000000000000000000000000100000 5 +0b00000000000000000000000001000000 6 +0b00000000000000000000000010000000 7 +0b00000000000000000000000100000000 8 +0b00000000000000000000001000000000 9 +0b00000000000000000000010000000000 10 +0b00000000000000000000100000000000 11 +0b00000000000000000001000000000000 12 +0b00000000000000000010000000000000 13 +0b00000000000000000100000000000000 14 +0b00000000000000001000000000000000 15 +0b00000000000000010000000000000000 16 +0b00000000000000100000000000000000 17 +0b00000000000001000000000000000000 18 +0b00000000000010000000000000000000 19 +0b00000000000100000000000000000000 20 +0b00000000001000000000000000000000 21 +0b00000000010000000000000000000000 22 +0b00000000100000000000000000000000 23 +0b00000001000000000000000000000000 24 +0b00000010000000000000000000000000 25 +0b00000100000000000000000000000000 26 +0b00001000000000000000000000000000 27 +0b00010000000000000000000000000000 28 +0b00100000000000000000000000000000 29 +0b01000000000000000000000000000000 30 +0b10000000000000000000000000000000 31 +0b00000000000000000000000000000000 32 + +unsigned int +0b00000000000000000000000000000001 0 +0b00000000000000000000000000000010 1 +0b00000000000000000000000000000100 2 +0b00000000000000000000000000001000 3 +0b00000000000000000000000000010000 4 +0b00000000000000000000000000100000 5 +0b00000000000000000000000001000000 6 +0b00000000000000000000000010000000 7 +0b00000000000000000000000100000000 8 +0b00000000000000000000001000000000 9 +0b00000000000000000000010000000000 10 +0b00000000000000000000100000000000 11 +0b00000000000000000001000000000000 12 +0b00000000000000000010000000000000 13 +0b00000000000000000100000000000000 14 +0b00000000000000001000000000000000 15 +0b00000000000000010000000000000000 16 +0b00000000000000100000000000000000 17 +0b00000000000001000000000000000000 18 +0b00000000000010000000000000000000 19 +0b00000000000100000000000000000000 20 +0b00000000001000000000000000000000 21 +0b00000000010000000000000000000000 22 +0b00000000100000000000000000000000 23 +0b00000001000000000000000000000000 24 +0b00000010000000000000000000000000 25 +0b00000100000000000000000000000000 26 +0b00001000000000000000000000000000 27 +0b00010000000000000000000000000000 28 +0b00100000000000000000000000000000 29 +0b01000000000000000000000000000000 30 +0b10000000000000000000000000000000 31 +0b00000000000000000000000000000000 32 + +long int +0b00000000000000000000000000000001 0 +0b00000000000000000000000000000010 1 +0b00000000000000000000000000000100 2 +0b00000000000000000000000000001000 3 +0b00000000000000000000000000010000 4 +0b00000000000000000000000000100000 5 +0b00000000000000000000000001000000 6 +0b00000000000000000000000010000000 7 +0b00000000000000000000000100000000 8 +0b00000000000000000000001000000000 9 +0b00000000000000000000010000000000 10 +0b00000000000000000000100000000000 11 +0b00000000000000000001000000000000 12 +0b00000000000000000010000000000000 13 +0b00000000000000000100000000000000 14 +0b00000000000000001000000000000000 15 +0b00000000000000010000000000000000 16 +0b00000000000000100000000000000000 17 +0b00000000000001000000000000000000 18 +0b00000000000010000000000000000000 19 +0b00000000000100000000000000000000 20 +0b00000000001000000000000000000000 21 +0b00000000010000000000000000000000 22 +0b00000000100000000000000000000000 23 +0b00000001000000000000000000000000 24 +0b00000010000000000000000000000000 25 +0b00000100000000000000000000000000 26 +0b00001000000000000000000000000000 27 +0b00010000000000000000000000000000 28 +0b00100000000000000000000000000000 29 +0b01000000000000000000000000000000 30 +0b10000000000000000000000000000000 31 +0b00000000000000000000000000000000 32 + +unsigned long int +0b00000000000000000000000000000001 0 +0b00000000000000000000000000000010 1 +0b00000000000000000000000000000100 2 +0b00000000000000000000000000001000 3 +0b00000000000000000000000000010000 4 +0b00000000000000000000000000100000 5 +0b00000000000000000000000001000000 6 +0b00000000000000000000000010000000 7 +0b00000000000000000000000100000000 8 +0b00000000000000000000001000000000 9 +0b00000000000000000000010000000000 10 +0b00000000000000000000100000000000 11 +0b00000000000000000001000000000000 12 +0b00000000000000000010000000000000 13 +0b00000000000000000100000000000000 14 +0b00000000000000001000000000000000 15 +0b00000000000000010000000000000000 16 +0b00000000000000100000000000000000 17 +0b00000000000001000000000000000000 18 +0b00000000000010000000000000000000 19 +0b00000000000100000000000000000000 20 +0b00000000001000000000000000000000 21 +0b00000000010000000000000000000000 22 +0b00000000100000000000000000000000 23 +0b00000001000000000000000000000000 24 +0b00000010000000000000000000000000 25 +0b00000100000000000000000000000000 26 +0b00001000000000000000000000000000 27 +0b00010000000000000000000000000000 28 +0b00100000000000000000000000000000 29 +0b01000000000000000000000000000000 30 +0b10000000000000000000000000000000 31 +0b00000000000000000000000000000000 32 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000001 0 +0b0000000000000000000000000000000000000000000000000000000000000010 1 +0b0000000000000000000000000000000000000000000000000000000000000100 2 +0b0000000000000000000000000000000000000000000000000000000000001000 3 +0b0000000000000000000000000000000000000000000000000000000000010000 4 +0b0000000000000000000000000000000000000000000000000000000000100000 5 +0b0000000000000000000000000000000000000000000000000000000001000000 6 +0b0000000000000000000000000000000000000000000000000000000010000000 7 +0b0000000000000000000000000000000000000000000000000000000100000000 8 +0b0000000000000000000000000000000000000000000000000000001000000000 9 +0b0000000000000000000000000000000000000000000000000000010000000000 10 +0b0000000000000000000000000000000000000000000000000000100000000000 11 +0b0000000000000000000000000000000000000000000000000001000000000000 12 +0b0000000000000000000000000000000000000000000000000010000000000000 13 +0b0000000000000000000000000000000000000000000000000100000000000000 14 +0b0000000000000000000000000000000000000000000000001000000000000000 15 +0b0000000000000000000000000000000000000000000000010000000000000000 16 +0b0000000000000000000000000000000000000000000000100000000000000000 17 +0b0000000000000000000000000000000000000000000001000000000000000000 18 +0b0000000000000000000000000000000000000000000010000000000000000000 19 +0b0000000000000000000000000000000000000000000100000000000000000000 20 +0b0000000000000000000000000000000000000000001000000000000000000000 21 +0b0000000000000000000000000000000000000000010000000000000000000000 22 +0b0000000000000000000000000000000000000000100000000000000000000000 23 +0b0000000000000000000000000000000000000001000000000000000000000000 24 +0b0000000000000000000000000000000000000010000000000000000000000000 25 +0b0000000000000000000000000000000000000100000000000000000000000000 26 +0b0000000000000000000000000000000000001000000000000000000000000000 27 +0b0000000000000000000000000000000000010000000000000000000000000000 28 +0b0000000000000000000000000000000000100000000000000000000000000000 29 +0b0000000000000000000000000000000001000000000000000000000000000000 30 +0b0000000000000000000000000000000010000000000000000000000000000000 31 +0b0000000000000000000000000000000100000000000000000000000000000000 32 +0b0000000000000000000000000000001000000000000000000000000000000000 33 +0b0000000000000000000000000000010000000000000000000000000000000000 34 +0b0000000000000000000000000000100000000000000000000000000000000000 35 +0b0000000000000000000000000001000000000000000000000000000000000000 36 +0b0000000000000000000000000010000000000000000000000000000000000000 37 +0b0000000000000000000000000100000000000000000000000000000000000000 38 +0b0000000000000000000000001000000000000000000000000000000000000000 39 +0b0000000000000000000000010000000000000000000000000000000000000000 40 +0b0000000000000000000000100000000000000000000000000000000000000000 41 +0b0000000000000000000001000000000000000000000000000000000000000000 42 +0b0000000000000000000010000000000000000000000000000000000000000000 43 +0b0000000000000000000100000000000000000000000000000000000000000000 44 +0b0000000000000000001000000000000000000000000000000000000000000000 45 +0b0000000000000000010000000000000000000000000000000000000000000000 46 +0b0000000000000000100000000000000000000000000000000000000000000000 47 +0b0000000000000001000000000000000000000000000000000000000000000000 48 +0b0000000000000010000000000000000000000000000000000000000000000000 49 +0b0000000000000100000000000000000000000000000000000000000000000000 50 +0b0000000000001000000000000000000000000000000000000000000000000000 51 +0b0000000000010000000000000000000000000000000000000000000000000000 52 +0b0000000000100000000000000000000000000000000000000000000000000000 53 +0b0000000001000000000000000000000000000000000000000000000000000000 54 +0b0000000010000000000000000000000000000000000000000000000000000000 55 +0b0000000100000000000000000000000000000000000000000000000000000000 56 +0b0000001000000000000000000000000000000000000000000000000000000000 57 +0b0000010000000000000000000000000000000000000000000000000000000000 58 +0b0000100000000000000000000000000000000000000000000000000000000000 59 +0b0001000000000000000000000000000000000000000000000000000000000000 60 +0b0010000000000000000000000000000000000000000000000000000000000000 61 +0b0100000000000000000000000000000000000000000000000000000000000000 62 +0b1000000000000000000000000000000000000000000000000000000000000000 63 +0b0000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000001 0 +0b0000000000000000000000000000000000000000000000000000000000000010 1 +0b0000000000000000000000000000000000000000000000000000000000000100 2 +0b0000000000000000000000000000000000000000000000000000000000001000 3 +0b0000000000000000000000000000000000000000000000000000000000010000 4 +0b0000000000000000000000000000000000000000000000000000000000100000 5 +0b0000000000000000000000000000000000000000000000000000000001000000 6 +0b0000000000000000000000000000000000000000000000000000000010000000 7 +0b0000000000000000000000000000000000000000000000000000000100000000 8 +0b0000000000000000000000000000000000000000000000000000001000000000 9 +0b0000000000000000000000000000000000000000000000000000010000000000 10 +0b0000000000000000000000000000000000000000000000000000100000000000 11 +0b0000000000000000000000000000000000000000000000000001000000000000 12 +0b0000000000000000000000000000000000000000000000000010000000000000 13 +0b0000000000000000000000000000000000000000000000000100000000000000 14 +0b0000000000000000000000000000000000000000000000001000000000000000 15 +0b0000000000000000000000000000000000000000000000010000000000000000 16 +0b0000000000000000000000000000000000000000000000100000000000000000 17 +0b0000000000000000000000000000000000000000000001000000000000000000 18 +0b0000000000000000000000000000000000000000000010000000000000000000 19 +0b0000000000000000000000000000000000000000000100000000000000000000 20 +0b0000000000000000000000000000000000000000001000000000000000000000 21 +0b0000000000000000000000000000000000000000010000000000000000000000 22 +0b0000000000000000000000000000000000000000100000000000000000000000 23 +0b0000000000000000000000000000000000000001000000000000000000000000 24 +0b0000000000000000000000000000000000000010000000000000000000000000 25 +0b0000000000000000000000000000000000000100000000000000000000000000 26 +0b0000000000000000000000000000000000001000000000000000000000000000 27 +0b0000000000000000000000000000000000010000000000000000000000000000 28 +0b0000000000000000000000000000000000100000000000000000000000000000 29 +0b0000000000000000000000000000000001000000000000000000000000000000 30 +0b0000000000000000000000000000000010000000000000000000000000000000 31 +0b0000000000000000000000000000000100000000000000000000000000000000 32 +0b0000000000000000000000000000001000000000000000000000000000000000 33 +0b0000000000000000000000000000010000000000000000000000000000000000 34 +0b0000000000000000000000000000100000000000000000000000000000000000 35 +0b0000000000000000000000000001000000000000000000000000000000000000 36 +0b0000000000000000000000000010000000000000000000000000000000000000 37 +0b0000000000000000000000000100000000000000000000000000000000000000 38 +0b0000000000000000000000001000000000000000000000000000000000000000 39 +0b0000000000000000000000010000000000000000000000000000000000000000 40 +0b0000000000000000000000100000000000000000000000000000000000000000 41 +0b0000000000000000000001000000000000000000000000000000000000000000 42 +0b0000000000000000000010000000000000000000000000000000000000000000 43 +0b0000000000000000000100000000000000000000000000000000000000000000 44 +0b0000000000000000001000000000000000000000000000000000000000000000 45 +0b0000000000000000010000000000000000000000000000000000000000000000 46 +0b0000000000000000100000000000000000000000000000000000000000000000 47 +0b0000000000000001000000000000000000000000000000000000000000000000 48 +0b0000000000000010000000000000000000000000000000000000000000000000 49 +0b0000000000000100000000000000000000000000000000000000000000000000 50 +0b0000000000001000000000000000000000000000000000000000000000000000 51 +0b0000000000010000000000000000000000000000000000000000000000000000 52 +0b0000000000100000000000000000000000000000000000000000000000000000 53 +0b0000000001000000000000000000000000000000000000000000000000000000 54 +0b0000000010000000000000000000000000000000000000000000000000000000 55 +0b0000000100000000000000000000000000000000000000000000000000000000 56 +0b0000001000000000000000000000000000000000000000000000000000000000 57 +0b0000010000000000000000000000000000000000000000000000000000000000 58 +0b0000100000000000000000000000000000000000000000000000000000000000 59 +0b0001000000000000000000000000000000000000000000000000000000000000 60 +0b0010000000000000000000000000000000000000000000000000000000000000 61 +0b0100000000000000000000000000000000000000000000000000000000000000 62 +0b1000000000000000000000000000000000000000000000000000000000000000 63 +0b0000000000000000000000000000000000000000000000000000000000000000 64 + + +all0s + +signed char +0b00000000 8 +0b00000001 7 +0b00000011 6 +0b00000111 5 +0b00001111 4 +0b00011111 3 +0b00111111 2 +0b01111111 1 +0b11111111 0 + +unsigned char +0b00000000 8 +0b00000001 7 +0b00000011 6 +0b00000111 5 +0b00001111 4 +0b00011111 3 +0b00111111 2 +0b01111111 1 +0b11111111 0 + +short int +0b0000000000000000 16 +0b0000000000000001 15 +0b0000000000000011 14 +0b0000000000000111 13 +0b0000000000001111 12 +0b0000000000011111 11 +0b0000000000111111 10 +0b0000000001111111 9 +0b0000000011111111 8 +0b0000000111111111 7 +0b0000001111111111 6 +0b0000011111111111 5 +0b0000111111111111 4 +0b0001111111111111 3 +0b0011111111111111 2 +0b0111111111111111 1 +0b1111111111111111 0 + +unsigned short int +0b0000000000000000 16 +0b0000000000000001 15 +0b0000000000000011 14 +0b0000000000000111 13 +0b0000000000001111 12 +0b0000000000011111 11 +0b0000000000111111 10 +0b0000000001111111 9 +0b0000000011111111 8 +0b0000000111111111 7 +0b0000001111111111 6 +0b0000011111111111 5 +0b0000111111111111 4 +0b0001111111111111 3 +0b0011111111111111 2 +0b0111111111111111 1 +0b1111111111111111 0 + +int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000011 30 +0b00000000000000000000000000000111 29 +0b00000000000000000000000000001111 28 +0b00000000000000000000000000011111 27 +0b00000000000000000000000000111111 26 +0b00000000000000000000000001111111 25 +0b00000000000000000000000011111111 24 +0b00000000000000000000000111111111 23 +0b00000000000000000000001111111111 22 +0b00000000000000000000011111111111 21 +0b00000000000000000000111111111111 20 +0b00000000000000000001111111111111 19 +0b00000000000000000011111111111111 18 +0b00000000000000000111111111111111 17 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 15 +0b00000000000000111111111111111111 14 +0b00000000000001111111111111111111 13 +0b00000000000011111111111111111111 12 +0b00000000000111111111111111111111 11 +0b00000000001111111111111111111111 10 +0b00000000011111111111111111111111 9 +0b00000000111111111111111111111111 8 +0b00000001111111111111111111111111 7 +0b00000011111111111111111111111111 6 +0b00000111111111111111111111111111 5 +0b00001111111111111111111111111111 4 +0b00011111111111111111111111111111 3 +0b00111111111111111111111111111111 2 +0b01111111111111111111111111111111 1 +0b11111111111111111111111111111111 0 + +unsigned int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000011 30 +0b00000000000000000000000000000111 29 +0b00000000000000000000000000001111 28 +0b00000000000000000000000000011111 27 +0b00000000000000000000000000111111 26 +0b00000000000000000000000001111111 25 +0b00000000000000000000000011111111 24 +0b00000000000000000000000111111111 23 +0b00000000000000000000001111111111 22 +0b00000000000000000000011111111111 21 +0b00000000000000000000111111111111 20 +0b00000000000000000001111111111111 19 +0b00000000000000000011111111111111 18 +0b00000000000000000111111111111111 17 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 15 +0b00000000000000111111111111111111 14 +0b00000000000001111111111111111111 13 +0b00000000000011111111111111111111 12 +0b00000000000111111111111111111111 11 +0b00000000001111111111111111111111 10 +0b00000000011111111111111111111111 9 +0b00000000111111111111111111111111 8 +0b00000001111111111111111111111111 7 +0b00000011111111111111111111111111 6 +0b00000111111111111111111111111111 5 +0b00001111111111111111111111111111 4 +0b00011111111111111111111111111111 3 +0b00111111111111111111111111111111 2 +0b01111111111111111111111111111111 1 +0b11111111111111111111111111111111 0 + +long int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000011 30 +0b00000000000000000000000000000111 29 +0b00000000000000000000000000001111 28 +0b00000000000000000000000000011111 27 +0b00000000000000000000000000111111 26 +0b00000000000000000000000001111111 25 +0b00000000000000000000000011111111 24 +0b00000000000000000000000111111111 23 +0b00000000000000000000001111111111 22 +0b00000000000000000000011111111111 21 +0b00000000000000000000111111111111 20 +0b00000000000000000001111111111111 19 +0b00000000000000000011111111111111 18 +0b00000000000000000111111111111111 17 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 15 +0b00000000000000111111111111111111 14 +0b00000000000001111111111111111111 13 +0b00000000000011111111111111111111 12 +0b00000000000111111111111111111111 11 +0b00000000001111111111111111111111 10 +0b00000000011111111111111111111111 9 +0b00000000111111111111111111111111 8 +0b00000001111111111111111111111111 7 +0b00000011111111111111111111111111 6 +0b00000111111111111111111111111111 5 +0b00001111111111111111111111111111 4 +0b00011111111111111111111111111111 3 +0b00111111111111111111111111111111 2 +0b01111111111111111111111111111111 1 +0b11111111111111111111111111111111 0 + +unsigned long int +0b00000000000000000000000000000000 32 +0b00000000000000000000000000000001 31 +0b00000000000000000000000000000011 30 +0b00000000000000000000000000000111 29 +0b00000000000000000000000000001111 28 +0b00000000000000000000000000011111 27 +0b00000000000000000000000000111111 26 +0b00000000000000000000000001111111 25 +0b00000000000000000000000011111111 24 +0b00000000000000000000000111111111 23 +0b00000000000000000000001111111111 22 +0b00000000000000000000011111111111 21 +0b00000000000000000000111111111111 20 +0b00000000000000000001111111111111 19 +0b00000000000000000011111111111111 18 +0b00000000000000000111111111111111 17 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 15 +0b00000000000000111111111111111111 14 +0b00000000000001111111111111111111 13 +0b00000000000011111111111111111111 12 +0b00000000000111111111111111111111 11 +0b00000000001111111111111111111111 10 +0b00000000011111111111111111111111 9 +0b00000000111111111111111111111111 8 +0b00000001111111111111111111111111 7 +0b00000011111111111111111111111111 6 +0b00000111111111111111111111111111 5 +0b00001111111111111111111111111111 4 +0b00011111111111111111111111111111 3 +0b00111111111111111111111111111111 2 +0b01111111111111111111111111111111 1 +0b11111111111111111111111111111111 0 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000011 62 +0b0000000000000000000000000000000000000000000000000000000000000111 61 +0b0000000000000000000000000000000000000000000000000000000000001111 60 +0b0000000000000000000000000000000000000000000000000000000000011111 59 +0b0000000000000000000000000000000000000000000000000000000000111111 58 +0b0000000000000000000000000000000000000000000000000000000001111111 57 +0b0000000000000000000000000000000000000000000000000000000011111111 56 +0b0000000000000000000000000000000000000000000000000000000111111111 55 +0b0000000000000000000000000000000000000000000000000000001111111111 54 +0b0000000000000000000000000000000000000000000000000000011111111111 53 +0b0000000000000000000000000000000000000000000000000000111111111111 52 +0b0000000000000000000000000000000000000000000000000001111111111111 51 +0b0000000000000000000000000000000000000000000000000011111111111111 50 +0b0000000000000000000000000000000000000000000000000111111111111111 49 +0b0000000000000000000000000000000000000000000000001111111111111111 48 +0b0000000000000000000000000000000000000000000000011111111111111111 47 +0b0000000000000000000000000000000000000000000000111111111111111111 46 +0b0000000000000000000000000000000000000000000001111111111111111111 45 +0b0000000000000000000000000000000000000000000011111111111111111111 44 +0b0000000000000000000000000000000000000000000111111111111111111111 43 +0b0000000000000000000000000000000000000000001111111111111111111111 42 +0b0000000000000000000000000000000000000000011111111111111111111111 41 +0b0000000000000000000000000000000000000000111111111111111111111111 40 +0b0000000000000000000000000000000000000001111111111111111111111111 39 +0b0000000000000000000000000000000000000011111111111111111111111111 38 +0b0000000000000000000000000000000000000111111111111111111111111111 37 +0b0000000000000000000000000000000000001111111111111111111111111111 36 +0b0000000000000000000000000000000000011111111111111111111111111111 35 +0b0000000000000000000000000000000000111111111111111111111111111111 34 +0b0000000000000000000000000000000001111111111111111111111111111111 33 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 31 +0b0000000000000000000000000000001111111111111111111111111111111111 30 +0b0000000000000000000000000000011111111111111111111111111111111111 29 +0b0000000000000000000000000000111111111111111111111111111111111111 28 +0b0000000000000000000000000001111111111111111111111111111111111111 27 +0b0000000000000000000000000011111111111111111111111111111111111111 26 +0b0000000000000000000000000111111111111111111111111111111111111111 25 +0b0000000000000000000000001111111111111111111111111111111111111111 24 +0b0000000000000000000000011111111111111111111111111111111111111111 23 +0b0000000000000000000000111111111111111111111111111111111111111111 22 +0b0000000000000000000001111111111111111111111111111111111111111111 21 +0b0000000000000000000011111111111111111111111111111111111111111111 20 +0b0000000000000000000111111111111111111111111111111111111111111111 19 +0b0000000000000000001111111111111111111111111111111111111111111111 18 +0b0000000000000000011111111111111111111111111111111111111111111111 17 +0b0000000000000000111111111111111111111111111111111111111111111111 16 +0b0000000000000001111111111111111111111111111111111111111111111111 15 +0b0000000000000011111111111111111111111111111111111111111111111111 14 +0b0000000000000111111111111111111111111111111111111111111111111111 13 +0b0000000000001111111111111111111111111111111111111111111111111111 12 +0b0000000000011111111111111111111111111111111111111111111111111111 11 +0b0000000000111111111111111111111111111111111111111111111111111111 10 +0b0000000001111111111111111111111111111111111111111111111111111111 9 +0b0000000011111111111111111111111111111111111111111111111111111111 8 +0b0000000111111111111111111111111111111111111111111111111111111111 7 +0b0000001111111111111111111111111111111111111111111111111111111111 6 +0b0000011111111111111111111111111111111111111111111111111111111111 5 +0b0000111111111111111111111111111111111111111111111111111111111111 4 +0b0001111111111111111111111111111111111111111111111111111111111111 3 +0b0011111111111111111111111111111111111111111111111111111111111111 2 +0b0111111111111111111111111111111111111111111111111111111111111111 1 +0b1111111111111111111111111111111111111111111111111111111111111111 0 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 64 +0b0000000000000000000000000000000000000000000000000000000000000001 63 +0b0000000000000000000000000000000000000000000000000000000000000011 62 +0b0000000000000000000000000000000000000000000000000000000000000111 61 +0b0000000000000000000000000000000000000000000000000000000000001111 60 +0b0000000000000000000000000000000000000000000000000000000000011111 59 +0b0000000000000000000000000000000000000000000000000000000000111111 58 +0b0000000000000000000000000000000000000000000000000000000001111111 57 +0b0000000000000000000000000000000000000000000000000000000011111111 56 +0b0000000000000000000000000000000000000000000000000000000111111111 55 +0b0000000000000000000000000000000000000000000000000000001111111111 54 +0b0000000000000000000000000000000000000000000000000000011111111111 53 +0b0000000000000000000000000000000000000000000000000000111111111111 52 +0b0000000000000000000000000000000000000000000000000001111111111111 51 +0b0000000000000000000000000000000000000000000000000011111111111111 50 +0b0000000000000000000000000000000000000000000000000111111111111111 49 +0b0000000000000000000000000000000000000000000000001111111111111111 48 +0b0000000000000000000000000000000000000000000000011111111111111111 47 +0b0000000000000000000000000000000000000000000000111111111111111111 46 +0b0000000000000000000000000000000000000000000001111111111111111111 45 +0b0000000000000000000000000000000000000000000011111111111111111111 44 +0b0000000000000000000000000000000000000000000111111111111111111111 43 +0b0000000000000000000000000000000000000000001111111111111111111111 42 +0b0000000000000000000000000000000000000000011111111111111111111111 41 +0b0000000000000000000000000000000000000000111111111111111111111111 40 +0b0000000000000000000000000000000000000001111111111111111111111111 39 +0b0000000000000000000000000000000000000011111111111111111111111111 38 +0b0000000000000000000000000000000000000111111111111111111111111111 37 +0b0000000000000000000000000000000000001111111111111111111111111111 36 +0b0000000000000000000000000000000000011111111111111111111111111111 35 +0b0000000000000000000000000000000000111111111111111111111111111111 34 +0b0000000000000000000000000000000001111111111111111111111111111111 33 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 31 +0b0000000000000000000000000000001111111111111111111111111111111111 30 +0b0000000000000000000000000000011111111111111111111111111111111111 29 +0b0000000000000000000000000000111111111111111111111111111111111111 28 +0b0000000000000000000000000001111111111111111111111111111111111111 27 +0b0000000000000000000000000011111111111111111111111111111111111111 26 +0b0000000000000000000000000111111111111111111111111111111111111111 25 +0b0000000000000000000000001111111111111111111111111111111111111111 24 +0b0000000000000000000000011111111111111111111111111111111111111111 23 +0b0000000000000000000000111111111111111111111111111111111111111111 22 +0b0000000000000000000001111111111111111111111111111111111111111111 21 +0b0000000000000000000011111111111111111111111111111111111111111111 20 +0b0000000000000000000111111111111111111111111111111111111111111111 19 +0b0000000000000000001111111111111111111111111111111111111111111111 18 +0b0000000000000000011111111111111111111111111111111111111111111111 17 +0b0000000000000000111111111111111111111111111111111111111111111111 16 +0b0000000000000001111111111111111111111111111111111111111111111111 15 +0b0000000000000011111111111111111111111111111111111111111111111111 14 +0b0000000000000111111111111111111111111111111111111111111111111111 13 +0b0000000000001111111111111111111111111111111111111111111111111111 12 +0b0000000000011111111111111111111111111111111111111111111111111111 11 +0b0000000000111111111111111111111111111111111111111111111111111111 10 +0b0000000001111111111111111111111111111111111111111111111111111111 9 +0b0000000011111111111111111111111111111111111111111111111111111111 8 +0b0000000111111111111111111111111111111111111111111111111111111111 7 +0b0000001111111111111111111111111111111111111111111111111111111111 6 +0b0000011111111111111111111111111111111111111111111111111111111111 5 +0b0000111111111111111111111111111111111111111111111111111111111111 4 +0b0001111111111111111111111111111111111111111111111111111111111111 3 +0b0011111111111111111111111111111111111111111111111111111111111111 2 +0b0111111111111111111111111111111111111111111111111111111111111111 1 +0b1111111111111111111111111111111111111111111111111111111111111111 0 + + +all1s + +signed char +0b00000000 0 +0b00000001 1 +0b00000011 2 +0b00000111 3 +0b00001111 4 +0b00011111 5 +0b00111111 6 +0b01111111 7 +0b11111111 8 + +unsigned char +0b00000000 0 +0b00000001 1 +0b00000011 2 +0b00000111 3 +0b00001111 4 +0b00011111 5 +0b00111111 6 +0b01111111 7 +0b11111111 8 + +short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000011 2 +0b0000000000000111 3 +0b0000000000001111 4 +0b0000000000011111 5 +0b0000000000111111 6 +0b0000000001111111 7 +0b0000000011111111 8 +0b0000000111111111 9 +0b0000001111111111 10 +0b0000011111111111 11 +0b0000111111111111 12 +0b0001111111111111 13 +0b0011111111111111 14 +0b0111111111111111 15 +0b1111111111111111 16 + +unsigned short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000011 2 +0b0000000000000111 3 +0b0000000000001111 4 +0b0000000000011111 5 +0b0000000000111111 6 +0b0000000001111111 7 +0b0000000011111111 8 +0b0000000111111111 9 +0b0000001111111111 10 +0b0000011111111111 11 +0b0000111111111111 12 +0b0001111111111111 13 +0b0011111111111111 14 +0b0111111111111111 15 +0b1111111111111111 16 + +int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000011 2 +0b00000000000000000000000000000111 3 +0b00000000000000000000000000001111 4 +0b00000000000000000000000000011111 5 +0b00000000000000000000000000111111 6 +0b00000000000000000000000001111111 7 +0b00000000000000000000000011111111 8 +0b00000000000000000000000111111111 9 +0b00000000000000000000001111111111 10 +0b00000000000000000000011111111111 11 +0b00000000000000000000111111111111 12 +0b00000000000000000001111111111111 13 +0b00000000000000000011111111111111 14 +0b00000000000000000111111111111111 15 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 17 +0b00000000000000111111111111111111 18 +0b00000000000001111111111111111111 19 +0b00000000000011111111111111111111 20 +0b00000000000111111111111111111111 21 +0b00000000001111111111111111111111 22 +0b00000000011111111111111111111111 23 +0b00000000111111111111111111111111 24 +0b00000001111111111111111111111111 25 +0b00000011111111111111111111111111 26 +0b00000111111111111111111111111111 27 +0b00001111111111111111111111111111 28 +0b00011111111111111111111111111111 29 +0b00111111111111111111111111111111 30 +0b01111111111111111111111111111111 31 +0b11111111111111111111111111111111 32 + +unsigned int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000011 2 +0b00000000000000000000000000000111 3 +0b00000000000000000000000000001111 4 +0b00000000000000000000000000011111 5 +0b00000000000000000000000000111111 6 +0b00000000000000000000000001111111 7 +0b00000000000000000000000011111111 8 +0b00000000000000000000000111111111 9 +0b00000000000000000000001111111111 10 +0b00000000000000000000011111111111 11 +0b00000000000000000000111111111111 12 +0b00000000000000000001111111111111 13 +0b00000000000000000011111111111111 14 +0b00000000000000000111111111111111 15 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 17 +0b00000000000000111111111111111111 18 +0b00000000000001111111111111111111 19 +0b00000000000011111111111111111111 20 +0b00000000000111111111111111111111 21 +0b00000000001111111111111111111111 22 +0b00000000011111111111111111111111 23 +0b00000000111111111111111111111111 24 +0b00000001111111111111111111111111 25 +0b00000011111111111111111111111111 26 +0b00000111111111111111111111111111 27 +0b00001111111111111111111111111111 28 +0b00011111111111111111111111111111 29 +0b00111111111111111111111111111111 30 +0b01111111111111111111111111111111 31 +0b11111111111111111111111111111111 32 + +long int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000011 2 +0b00000000000000000000000000000111 3 +0b00000000000000000000000000001111 4 +0b00000000000000000000000000011111 5 +0b00000000000000000000000000111111 6 +0b00000000000000000000000001111111 7 +0b00000000000000000000000011111111 8 +0b00000000000000000000000111111111 9 +0b00000000000000000000001111111111 10 +0b00000000000000000000011111111111 11 +0b00000000000000000000111111111111 12 +0b00000000000000000001111111111111 13 +0b00000000000000000011111111111111 14 +0b00000000000000000111111111111111 15 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 17 +0b00000000000000111111111111111111 18 +0b00000000000001111111111111111111 19 +0b00000000000011111111111111111111 20 +0b00000000000111111111111111111111 21 +0b00000000001111111111111111111111 22 +0b00000000011111111111111111111111 23 +0b00000000111111111111111111111111 24 +0b00000001111111111111111111111111 25 +0b00000011111111111111111111111111 26 +0b00000111111111111111111111111111 27 +0b00001111111111111111111111111111 28 +0b00011111111111111111111111111111 29 +0b00111111111111111111111111111111 30 +0b01111111111111111111111111111111 31 +0b11111111111111111111111111111111 32 + +unsigned long int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000011 2 +0b00000000000000000000000000000111 3 +0b00000000000000000000000000001111 4 +0b00000000000000000000000000011111 5 +0b00000000000000000000000000111111 6 +0b00000000000000000000000001111111 7 +0b00000000000000000000000011111111 8 +0b00000000000000000000000111111111 9 +0b00000000000000000000001111111111 10 +0b00000000000000000000011111111111 11 +0b00000000000000000000111111111111 12 +0b00000000000000000001111111111111 13 +0b00000000000000000011111111111111 14 +0b00000000000000000111111111111111 15 +0b00000000000000001111111111111111 16 +0b00000000000000011111111111111111 17 +0b00000000000000111111111111111111 18 +0b00000000000001111111111111111111 19 +0b00000000000011111111111111111111 20 +0b00000000000111111111111111111111 21 +0b00000000001111111111111111111111 22 +0b00000000011111111111111111111111 23 +0b00000000111111111111111111111111 24 +0b00000001111111111111111111111111 25 +0b00000011111111111111111111111111 26 +0b00000111111111111111111111111111 27 +0b00001111111111111111111111111111 28 +0b00011111111111111111111111111111 29 +0b00111111111111111111111111111111 30 +0b01111111111111111111111111111111 31 +0b11111111111111111111111111111111 32 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000011 2 +0b0000000000000000000000000000000000000000000000000000000000000111 3 +0b0000000000000000000000000000000000000000000000000000000000001111 4 +0b0000000000000000000000000000000000000000000000000000000000011111 5 +0b0000000000000000000000000000000000000000000000000000000000111111 6 +0b0000000000000000000000000000000000000000000000000000000001111111 7 +0b0000000000000000000000000000000000000000000000000000000011111111 8 +0b0000000000000000000000000000000000000000000000000000000111111111 9 +0b0000000000000000000000000000000000000000000000000000001111111111 10 +0b0000000000000000000000000000000000000000000000000000011111111111 11 +0b0000000000000000000000000000000000000000000000000000111111111111 12 +0b0000000000000000000000000000000000000000000000000001111111111111 13 +0b0000000000000000000000000000000000000000000000000011111111111111 14 +0b0000000000000000000000000000000000000000000000000111111111111111 15 +0b0000000000000000000000000000000000000000000000001111111111111111 16 +0b0000000000000000000000000000000000000000000000011111111111111111 17 +0b0000000000000000000000000000000000000000000000111111111111111111 18 +0b0000000000000000000000000000000000000000000001111111111111111111 19 +0b0000000000000000000000000000000000000000000011111111111111111111 20 +0b0000000000000000000000000000000000000000000111111111111111111111 21 +0b0000000000000000000000000000000000000000001111111111111111111111 22 +0b0000000000000000000000000000000000000000011111111111111111111111 23 +0b0000000000000000000000000000000000000000111111111111111111111111 24 +0b0000000000000000000000000000000000000001111111111111111111111111 25 +0b0000000000000000000000000000000000000011111111111111111111111111 26 +0b0000000000000000000000000000000000000111111111111111111111111111 27 +0b0000000000000000000000000000000000001111111111111111111111111111 28 +0b0000000000000000000000000000000000011111111111111111111111111111 29 +0b0000000000000000000000000000000000111111111111111111111111111111 30 +0b0000000000000000000000000000000001111111111111111111111111111111 31 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 33 +0b0000000000000000000000000000001111111111111111111111111111111111 34 +0b0000000000000000000000000000011111111111111111111111111111111111 35 +0b0000000000000000000000000000111111111111111111111111111111111111 36 +0b0000000000000000000000000001111111111111111111111111111111111111 37 +0b0000000000000000000000000011111111111111111111111111111111111111 38 +0b0000000000000000000000000111111111111111111111111111111111111111 39 +0b0000000000000000000000001111111111111111111111111111111111111111 40 +0b0000000000000000000000011111111111111111111111111111111111111111 41 +0b0000000000000000000000111111111111111111111111111111111111111111 42 +0b0000000000000000000001111111111111111111111111111111111111111111 43 +0b0000000000000000000011111111111111111111111111111111111111111111 44 +0b0000000000000000000111111111111111111111111111111111111111111111 45 +0b0000000000000000001111111111111111111111111111111111111111111111 46 +0b0000000000000000011111111111111111111111111111111111111111111111 47 +0b0000000000000000111111111111111111111111111111111111111111111111 48 +0b0000000000000001111111111111111111111111111111111111111111111111 49 +0b0000000000000011111111111111111111111111111111111111111111111111 50 +0b0000000000000111111111111111111111111111111111111111111111111111 51 +0b0000000000001111111111111111111111111111111111111111111111111111 52 +0b0000000000011111111111111111111111111111111111111111111111111111 53 +0b0000000000111111111111111111111111111111111111111111111111111111 54 +0b0000000001111111111111111111111111111111111111111111111111111111 55 +0b0000000011111111111111111111111111111111111111111111111111111111 56 +0b0000000111111111111111111111111111111111111111111111111111111111 57 +0b0000001111111111111111111111111111111111111111111111111111111111 58 +0b0000011111111111111111111111111111111111111111111111111111111111 59 +0b0000111111111111111111111111111111111111111111111111111111111111 60 +0b0001111111111111111111111111111111111111111111111111111111111111 61 +0b0011111111111111111111111111111111111111111111111111111111111111 62 +0b0111111111111111111111111111111111111111111111111111111111111111 63 +0b1111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000011 2 +0b0000000000000000000000000000000000000000000000000000000000000111 3 +0b0000000000000000000000000000000000000000000000000000000000001111 4 +0b0000000000000000000000000000000000000000000000000000000000011111 5 +0b0000000000000000000000000000000000000000000000000000000000111111 6 +0b0000000000000000000000000000000000000000000000000000000001111111 7 +0b0000000000000000000000000000000000000000000000000000000011111111 8 +0b0000000000000000000000000000000000000000000000000000000111111111 9 +0b0000000000000000000000000000000000000000000000000000001111111111 10 +0b0000000000000000000000000000000000000000000000000000011111111111 11 +0b0000000000000000000000000000000000000000000000000000111111111111 12 +0b0000000000000000000000000000000000000000000000000001111111111111 13 +0b0000000000000000000000000000000000000000000000000011111111111111 14 +0b0000000000000000000000000000000000000000000000000111111111111111 15 +0b0000000000000000000000000000000000000000000000001111111111111111 16 +0b0000000000000000000000000000000000000000000000011111111111111111 17 +0b0000000000000000000000000000000000000000000000111111111111111111 18 +0b0000000000000000000000000000000000000000000001111111111111111111 19 +0b0000000000000000000000000000000000000000000011111111111111111111 20 +0b0000000000000000000000000000000000000000000111111111111111111111 21 +0b0000000000000000000000000000000000000000001111111111111111111111 22 +0b0000000000000000000000000000000000000000011111111111111111111111 23 +0b0000000000000000000000000000000000000000111111111111111111111111 24 +0b0000000000000000000000000000000000000001111111111111111111111111 25 +0b0000000000000000000000000000000000000011111111111111111111111111 26 +0b0000000000000000000000000000000000000111111111111111111111111111 27 +0b0000000000000000000000000000000000001111111111111111111111111111 28 +0b0000000000000000000000000000000000011111111111111111111111111111 29 +0b0000000000000000000000000000000000111111111111111111111111111111 30 +0b0000000000000000000000000000000001111111111111111111111111111111 31 +0b0000000000000000000000000000000011111111111111111111111111111111 32 +0b0000000000000000000000000000000111111111111111111111111111111111 33 +0b0000000000000000000000000000001111111111111111111111111111111111 34 +0b0000000000000000000000000000011111111111111111111111111111111111 35 +0b0000000000000000000000000000111111111111111111111111111111111111 36 +0b0000000000000000000000000001111111111111111111111111111111111111 37 +0b0000000000000000000000000011111111111111111111111111111111111111 38 +0b0000000000000000000000000111111111111111111111111111111111111111 39 +0b0000000000000000000000001111111111111111111111111111111111111111 40 +0b0000000000000000000000011111111111111111111111111111111111111111 41 +0b0000000000000000000000111111111111111111111111111111111111111111 42 +0b0000000000000000000001111111111111111111111111111111111111111111 43 +0b0000000000000000000011111111111111111111111111111111111111111111 44 +0b0000000000000000000111111111111111111111111111111111111111111111 45 +0b0000000000000000001111111111111111111111111111111111111111111111 46 +0b0000000000000000011111111111111111111111111111111111111111111111 47 +0b0000000000000000111111111111111111111111111111111111111111111111 48 +0b0000000000000001111111111111111111111111111111111111111111111111 49 +0b0000000000000011111111111111111111111111111111111111111111111111 50 +0b0000000000000111111111111111111111111111111111111111111111111111 51 +0b0000000000001111111111111111111111111111111111111111111111111111 52 +0b0000000000011111111111111111111111111111111111111111111111111111 53 +0b0000000000111111111111111111111111111111111111111111111111111111 54 +0b0000000001111111111111111111111111111111111111111111111111111111 55 +0b0000000011111111111111111111111111111111111111111111111111111111 56 +0b0000000111111111111111111111111111111111111111111111111111111111 57 +0b0000001111111111111111111111111111111111111111111111111111111111 58 +0b0000011111111111111111111111111111111111111111111111111111111111 59 +0b0000111111111111111111111111111111111111111111111111111111111111 60 +0b0001111111111111111111111111111111111111111111111111111111111111 61 +0b0011111111111111111111111111111111111111111111111111111111111111 62 +0b0111111111111111111111111111111111111111111111111111111111111111 63 +0b1111111111111111111111111111111111111111111111111111111111111111 64 + Index: tests/.expect/bitmanip2.x64.txt =================================================================== --- tests/.expect/bitmanip2.x64.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/.expect/bitmanip2.x64.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1604 @@ + +low0 + +signed char +0b11111111 0 +0b11111110 1 +0b11111101 2 +0b11111011 3 +0b11110111 4 +0b11101111 5 +0b11011111 6 +0b10111111 7 +0b01111111 8 + +unsigned char +0b11111111 0 +0b11111110 1 +0b11111101 2 +0b11111011 3 +0b11110111 4 +0b11101111 5 +0b11011111 6 +0b10111111 7 +0b01111111 8 + +short int +0b1111111111111111 0 +0b1111111111111110 1 +0b1111111111111101 2 +0b1111111111111011 3 +0b1111111111110111 4 +0b1111111111101111 5 +0b1111111111011111 6 +0b1111111110111111 7 +0b1111111101111111 8 +0b1111111011111111 9 +0b1111110111111111 10 +0b1111101111111111 11 +0b1111011111111111 12 +0b1110111111111111 13 +0b1101111111111111 14 +0b1011111111111111 15 +0b0111111111111111 16 + +unsigned short int +0b1111111111111111 0 +0b1111111111111110 1 +0b1111111111111101 2 +0b1111111111111011 3 +0b1111111111110111 4 +0b1111111111101111 5 +0b1111111111011111 6 +0b1111111110111111 7 +0b1111111101111111 8 +0b1111111011111111 9 +0b1111110111111111 10 +0b1111101111111111 11 +0b1111011111111111 12 +0b1110111111111111 13 +0b1101111111111111 14 +0b1011111111111111 15 +0b0111111111111111 16 + +int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +unsigned int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + +long long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + + +low1 + +signed char +0b00000000 0 +0b00000001 1 +0b00000010 2 +0b00000100 3 +0b00001000 4 +0b00010000 5 +0b00100000 6 +0b01000000 7 +0b10000000 8 + +unsigned char +0b00000000 0 +0b00000001 1 +0b00000010 2 +0b00000100 3 +0b00001000 4 +0b00010000 5 +0b00100000 6 +0b01000000 7 +0b10000000 8 + +short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000010 2 +0b0000000000000100 3 +0b0000000000001000 4 +0b0000000000010000 5 +0b0000000000100000 6 +0b0000000001000000 7 +0b0000000010000000 8 +0b0000000100000000 9 +0b0000001000000000 10 +0b0000010000000000 11 +0b0000100000000000 12 +0b0001000000000000 13 +0b0010000000000000 14 +0b0100000000000000 15 +0b1000000000000000 16 + +unsigned short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000010 2 +0b0000000000000100 3 +0b0000000000001000 4 +0b0000000000010000 5 +0b0000000000100000 6 +0b0000000001000000 7 +0b0000000010000000 8 +0b0000000100000000 9 +0b0000001000000000 10 +0b0000010000000000 11 +0b0000100000000000 12 +0b0001000000000000 13 +0b0010000000000000 14 +0b0100000000000000 15 +0b1000000000000000 16 + +int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +unsigned int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000000 1 +0b0000000000000000000000000000000000000000000000000000000000000000 2 +0b0000000000000000000000000000000000000000000000000000000000000000 3 +0b0000000000000000000000000000000000000000000000000000000000000000 4 +0b0000000000000000000000000000000000000000000000000000000000000000 5 +0b0000000000000000000000000000000000000000000000000000000000000000 6 +0b0000000000000000000000000000000000000000000000000000000000000000 7 +0b0000000000000000000000000000000000000000000000000000000000000000 8 +0b0000000000000000000000000000000000000000000000000000000000000000 9 +0b0000000000000000000000000000000000000000000000000000000000000000 10 +0b0000000000000000000000000000000000000000000000000000000000000000 11 +0b0000000000000000000000000000000000000000000000000000000000000000 12 +0b0000000000000000000000000000000000000000000000000000000000000000 13 +0b0000000000000000000000000000000000000000000000000000000000000000 14 +0b0000000000000000000000000000000000000000000000000000000000000000 15 +0b0000000000000000000000000000000000000000000000000000000000000000 16 +0b0000000000000000000000000000000000000000000000000000000000000000 17 +0b0000000000000000000000000000000000000000000000000000000000000000 18 +0b0000000000000000000000000000000000000000000000000000000000000000 19 +0b0000000000000000000000000000000000000000000000000000000000000000 20 +0b0000000000000000000000000000000000000000000000000000000000000000 21 +0b0000000000000000000000000000000000000000000000000000000000000000 22 +0b0000000000000000000000000000000000000000000000000000000000000000 23 +0b0000000000000000000000000000000000000000000000000000000000000000 24 +0b0000000000000000000000000000000000000000000000000000000000000000 25 +0b0000000000000000000000000000000000000000000000000000000000000000 26 +0b0000000000000000000000000000000000000000000000000000000000000000 27 +0b0000000000000000000000000000000000000000000000000000000000000000 28 +0b0000000000000000000000000000000000000000000000000000000000000000 29 +0b0000000000000000000000000000000000000000000000000000000000000000 30 +0b0000000000000000000000000000000000000000000000000000000000000000 31 +0b0000000000000000000000000000000000000000000000000000000000000000 32 +0b0000000000000000000000000000000000000000000000000000000000000000 33 +0b0000000000000000000000000000000000000000000000000000000000000000 34 +0b0000000000000000000000000000000000000000000000000000000000000000 35 +0b0000000000000000000000000000000000000000000000000000000000000000 36 +0b0000000000000000000000000000000000000000000000000000000000000000 37 +0b0000000000000000000000000000000000000000000000000000000000000000 38 +0b0000000000000000000000000000000000000000000000000000000000000000 39 +0b0000000000000000000000000000000000000000000000000000000000000000 40 +0b0000000000000000000000000000000000000000000000000000000000000000 41 +0b0000000000000000000000000000000000000000000000000000000000000000 42 +0b0000000000000000000000000000000000000000000000000000000000000000 43 +0b0000000000000000000000000000000000000000000000000000000000000000 44 +0b0000000000000000000000000000000000000000000000000000000000000000 45 +0b0000000000000000000000000000000000000000000000000000000000000000 46 +0b0000000000000000000000000000000000000000000000000000000000000000 47 +0b0000000000000000000000000000000000000000000000000000000000000000 48 +0b0000000000000000000000000000000000000000000000000000000000000000 49 +0b0000000000000000000000000000000000000000000000000000000000000000 50 +0b0000000000000000000000000000000000000000000000000000000000000000 51 +0b0000000000000000000000000000000000000000000000000000000000000000 52 +0b0000000000000000000000000000000000000000000000000000000000000000 53 +0b0000000000000000000000000000000000000000000000000000000000000000 54 +0b0000000000000000000000000000000000000000000000000000000000000000 55 +0b0000000000000000000000000000000000000000000000000000000000000000 56 +0b0000000000000000000000000000000000000000000000000000000000000000 57 +0b0000000000000000000000000000000000000000000000000000000000000000 58 +0b0000000000000000000000000000000000000000000000000000000000000000 59 +0b0000000000000000000000000000000000000000000000000000000000000000 60 +0b0000000000000000000000000000000000000000000000000000000000000000 61 +0b0000000000000000000000000000000000000000000000000000000000000000 62 +0b0000000000000000000000000000000000000000000000000000000000000000 63 +0b0000000000000000000000000000000000000000000000000000000000000000 64 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + + +high0 + +signed char +0b11111111 0 +0b11111110 1 +0b11111101 2 +0b11111011 3 +0b11110111 4 +0b11101111 5 +0b11011111 6 +0b10111111 7 +0b01111111 8 + +unsigned char +0b11111111 0 +0b11111110 1 +0b11111101 2 +0b11111011 3 +0b11110111 4 +0b11101111 5 +0b11011111 6 +0b10111111 7 +0b01111111 8 + +short int +0b1111111111111111 0 +0b1111111111111110 1 +0b1111111111111101 2 +0b1111111111111011 3 +0b1111111111110111 4 +0b1111111111101111 5 +0b1111111111011111 6 +0b1111111110111111 7 +0b1111111101111111 8 +0b1111111011111111 9 +0b1111110111111111 10 +0b1111101111111111 11 +0b1111011111111111 12 +0b1110111111111111 13 +0b1101111111111111 14 +0b1011111111111111 15 +0b0111111111111111 16 + +unsigned short int +0b1111111111111111 0 +0b1111111111111110 1 +0b1111111111111101 2 +0b1111111111111011 3 +0b1111111111110111 4 +0b1111111111101111 5 +0b1111111111011111 6 +0b1111111110111111 7 +0b1111111101111111 8 +0b1111111011111111 9 +0b1111110111111111 10 +0b1111101111111111 11 +0b1111011111111111 12 +0b1110111111111111 13 +0b1101111111111111 14 +0b1011111111111111 15 +0b0111111111111111 16 + +int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +unsigned int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 0 +0b11111111111111111111111111111101 0 +0b11111111111111111111111111111011 0 +0b11111111111111111111111111110111 0 +0b11111111111111111111111111101111 0 +0b11111111111111111111111111011111 0 +0b11111111111111111111111110111111 0 +0b11111111111111111111111101111111 0 +0b11111111111111111111111011111111 0 +0b11111111111111111111110111111111 0 +0b11111111111111111111101111111111 0 +0b11111111111111111111011111111111 0 +0b11111111111111111110111111111111 0 +0b11111111111111111101111111111111 0 +0b11111111111111111011111111111111 0 +0b11111111111111110111111111111111 0 +0b11111111111111101111111111111111 0 +0b11111111111111011111111111111111 0 +0b11111111111110111111111111111111 0 +0b11111111111101111111111111111111 0 +0b11111111111011111111111111111111 0 +0b11111111110111111111111111111111 0 +0b11111111101111111111111111111111 0 +0b11111111011111111111111111111111 0 +0b11111110111111111111111111111111 0 +0b11111101111111111111111111111111 0 +0b11111011111111111111111111111111 0 +0b11110111111111111111111111111111 0 +0b11101111111111111111111111111111 0 +0b11011111111111111111111111111111 0 +0b10111111111111111111111111111111 0 +0b01111111111111111111111111111111 0 + +long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + +long long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + + +high1 + +signed char +0b00000000 0 +0b00000001 1 +0b00000010 2 +0b00000100 3 +0b00001000 4 +0b00010000 5 +0b00100000 6 +0b01000000 7 +0b10000000 8 + +unsigned char +0b00000000 0 +0b00000001 1 +0b00000010 2 +0b00000100 3 +0b00001000 4 +0b00010000 5 +0b00100000 6 +0b01000000 7 +0b10000000 8 + +short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000010 2 +0b0000000000000100 3 +0b0000000000001000 4 +0b0000000000010000 5 +0b0000000000100000 6 +0b0000000001000000 7 +0b0000000010000000 8 +0b0000000100000000 9 +0b0000001000000000 10 +0b0000010000000000 11 +0b0000100000000000 12 +0b0001000000000000 13 +0b0010000000000000 14 +0b0100000000000000 15 +0b1000000000000000 16 + +unsigned short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000010 2 +0b0000000000000100 3 +0b0000000000001000 4 +0b0000000000010000 5 +0b0000000000100000 6 +0b0000000001000000 7 +0b0000000010000000 8 +0b0000000100000000 9 +0b0000001000000000 10 +0b0000010000000000 11 +0b0000100000000000 12 +0b0001000000000000 13 +0b0010000000000000 14 +0b0100000000000000 15 +0b1000000000000000 16 + +int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +unsigned int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + Index: tests/.expect/bitmanip2.x86.txt =================================================================== --- tests/.expect/bitmanip2.x86.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/.expect/bitmanip2.x86.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1348 @@ + +low0 + +signed char +0b11111111 0 +0b11111110 1 +0b11111101 2 +0b11111011 3 +0b11110111 4 +0b11101111 5 +0b11011111 6 +0b10111111 7 +0b01111111 8 + +unsigned char +0b11111111 0 +0b11111110 1 +0b11111101 2 +0b11111011 3 +0b11110111 4 +0b11101111 5 +0b11011111 6 +0b10111111 7 +0b01111111 8 + +short int +0b1111111111111111 0 +0b1111111111111110 1 +0b1111111111111101 2 +0b1111111111111011 3 +0b1111111111110111 4 +0b1111111111101111 5 +0b1111111111011111 6 +0b1111111110111111 7 +0b1111111101111111 8 +0b1111111011111111 9 +0b1111110111111111 10 +0b1111101111111111 11 +0b1111011111111111 12 +0b1110111111111111 13 +0b1101111111111111 14 +0b1011111111111111 15 +0b0111111111111111 16 + +unsigned short int +0b1111111111111111 0 +0b1111111111111110 1 +0b1111111111111101 2 +0b1111111111111011 3 +0b1111111111110111 4 +0b1111111111101111 5 +0b1111111111011111 6 +0b1111111110111111 7 +0b1111111101111111 8 +0b1111111011111111 9 +0b1111110111111111 10 +0b1111101111111111 11 +0b1111011111111111 12 +0b1110111111111111 13 +0b1101111111111111 14 +0b1011111111111111 15 +0b0111111111111111 16 + +int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +unsigned int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +long int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +unsigned long int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +long long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + + +low1 + +signed char +0b00000000 0 +0b00000001 1 +0b00000010 2 +0b00000100 3 +0b00001000 4 +0b00010000 5 +0b00100000 6 +0b01000000 7 +0b10000000 8 + +unsigned char +0b00000000 0 +0b00000001 1 +0b00000010 2 +0b00000100 3 +0b00001000 4 +0b00010000 5 +0b00100000 6 +0b01000000 7 +0b10000000 8 + +short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000010 2 +0b0000000000000100 3 +0b0000000000001000 4 +0b0000000000010000 5 +0b0000000000100000 6 +0b0000000001000000 7 +0b0000000010000000 8 +0b0000000100000000 9 +0b0000001000000000 10 +0b0000010000000000 11 +0b0000100000000000 12 +0b0001000000000000 13 +0b0010000000000000 14 +0b0100000000000000 15 +0b1000000000000000 16 + +unsigned short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000010 2 +0b0000000000000100 3 +0b0000000000001000 4 +0b0000000000010000 5 +0b0000000000100000 6 +0b0000000001000000 7 +0b0000000010000000 8 +0b0000000100000000 9 +0b0000001000000000 10 +0b0000010000000000 11 +0b0000100000000000 12 +0b0001000000000000 13 +0b0010000000000000 14 +0b0100000000000000 15 +0b1000000000000000 16 + +int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +unsigned int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +long int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +unsigned long int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000000 1 +0b00000000000000000000000000000000 2 +0b00000000000000000000000000000000 3 +0b00000000000000000000000000000000 4 +0b00000000000000000000000000000000 5 +0b00000000000000000000000000000000 6 +0b00000000000000000000000000000000 7 +0b00000000000000000000000000000000 8 +0b00000000000000000000000000000000 9 +0b00000000000000000000000000000000 10 +0b00000000000000000000000000000000 11 +0b00000000000000000000000000000000 12 +0b00000000000000000000000000000000 13 +0b00000000000000000000000000000000 14 +0b00000000000000000000000000000000 15 +0b00000000000000000000000000000000 16 +0b00000000000000000000000000000000 17 +0b00000000000000000000000000000000 18 +0b00000000000000000000000000000000 19 +0b00000000000000000000000000000000 20 +0b00000000000000000000000000000000 21 +0b00000000000000000000000000000000 22 +0b00000000000000000000000000000000 23 +0b00000000000000000000000000000000 24 +0b00000000000000000000000000000000 25 +0b00000000000000000000000000000000 26 +0b00000000000000000000000000000000 27 +0b00000000000000000000000000000000 28 +0b00000000000000000000000000000000 29 +0b00000000000000000000000000000000 30 +0b00000000000000000000000000000000 31 +0b00000000000000000000000000000000 32 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + + +high0 + +signed char +0b11111111 0 +0b11111110 1 +0b11111101 2 +0b11111011 3 +0b11110111 4 +0b11101111 5 +0b11011111 6 +0b10111111 7 +0b01111111 8 + +unsigned char +0b11111111 0 +0b11111110 1 +0b11111101 2 +0b11111011 3 +0b11110111 4 +0b11101111 5 +0b11011111 6 +0b10111111 7 +0b01111111 8 + +short int +0b1111111111111111 0 +0b1111111111111110 1 +0b1111111111111101 2 +0b1111111111111011 3 +0b1111111111110111 4 +0b1111111111101111 5 +0b1111111111011111 6 +0b1111111110111111 7 +0b1111111101111111 8 +0b1111111011111111 9 +0b1111110111111111 10 +0b1111101111111111 11 +0b1111011111111111 12 +0b1110111111111111 13 +0b1101111111111111 14 +0b1011111111111111 15 +0b0111111111111111 16 + +unsigned short int +0b1111111111111111 0 +0b1111111111111110 1 +0b1111111111111101 2 +0b1111111111111011 3 +0b1111111111110111 4 +0b1111111111101111 5 +0b1111111111011111 6 +0b1111111110111111 7 +0b1111111101111111 8 +0b1111111011111111 9 +0b1111110111111111 10 +0b1111101111111111 11 +0b1111011111111111 12 +0b1110111111111111 13 +0b1101111111111111 14 +0b1011111111111111 15 +0b0111111111111111 16 + +int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +unsigned int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 0 +0b11111111111111111111111111111101 0 +0b11111111111111111111111111111011 0 +0b11111111111111111111111111110111 0 +0b11111111111111111111111111101111 0 +0b11111111111111111111111111011111 0 +0b11111111111111111111111110111111 0 +0b11111111111111111111111101111111 0 +0b11111111111111111111111011111111 0 +0b11111111111111111111110111111111 0 +0b11111111111111111111101111111111 0 +0b11111111111111111111011111111111 0 +0b11111111111111111110111111111111 0 +0b11111111111111111101111111111111 0 +0b11111111111111111011111111111111 0 +0b11111111111111110111111111111111 0 +0b11111111111111101111111111111111 0 +0b11111111111111011111111111111111 0 +0b11111111111110111111111111111111 0 +0b11111111111101111111111111111111 0 +0b11111111111011111111111111111111 0 +0b11111111110111111111111111111111 0 +0b11111111101111111111111111111111 0 +0b11111111011111111111111111111111 0 +0b11111110111111111111111111111111 0 +0b11111101111111111111111111111111 0 +0b11111011111111111111111111111111 0 +0b11110111111111111111111111111111 0 +0b11101111111111111111111111111111 0 +0b11011111111111111111111111111111 0 +0b10111111111111111111111111111111 0 +0b01111111111111111111111111111111 0 + +long int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +unsigned long int +0b11111111111111111111111111111111 0 +0b11111111111111111111111111111110 1 +0b11111111111111111111111111111101 2 +0b11111111111111111111111111111011 3 +0b11111111111111111111111111110111 4 +0b11111111111111111111111111101111 5 +0b11111111111111111111111111011111 6 +0b11111111111111111111111110111111 7 +0b11111111111111111111111101111111 8 +0b11111111111111111111111011111111 9 +0b11111111111111111111110111111111 10 +0b11111111111111111111101111111111 11 +0b11111111111111111111011111111111 12 +0b11111111111111111110111111111111 13 +0b11111111111111111101111111111111 14 +0b11111111111111111011111111111111 15 +0b11111111111111110111111111111111 16 +0b11111111111111101111111111111111 17 +0b11111111111111011111111111111111 18 +0b11111111111110111111111111111111 19 +0b11111111111101111111111111111111 20 +0b11111111111011111111111111111111 21 +0b11111111110111111111111111111111 22 +0b11111111101111111111111111111111 23 +0b11111111011111111111111111111111 24 +0b11111110111111111111111111111111 25 +0b11111101111111111111111111111111 26 +0b11111011111111111111111111111111 27 +0b11110111111111111111111111111111 28 +0b11101111111111111111111111111111 29 +0b11011111111111111111111111111111 30 +0b10111111111111111111111111111111 31 +0b01111111111111111111111111111111 32 + +long long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + +unsigned long long int +0b1111111111111111111111111111111111111111111111111111111111111111 0 +0b1111111111111111111111111111111111111111111111111111111111111110 1 +0b1111111111111111111111111111111111111111111111111111111111111101 2 +0b1111111111111111111111111111111111111111111111111111111111111011 3 +0b1111111111111111111111111111111111111111111111111111111111110111 4 +0b1111111111111111111111111111111111111111111111111111111111101111 5 +0b1111111111111111111111111111111111111111111111111111111111011111 6 +0b1111111111111111111111111111111111111111111111111111111110111111 7 +0b1111111111111111111111111111111111111111111111111111111101111111 8 +0b1111111111111111111111111111111111111111111111111111111011111111 9 +0b1111111111111111111111111111111111111111111111111111110111111111 10 +0b1111111111111111111111111111111111111111111111111111101111111111 11 +0b1111111111111111111111111111111111111111111111111111011111111111 12 +0b1111111111111111111111111111111111111111111111111110111111111111 13 +0b1111111111111111111111111111111111111111111111111101111111111111 14 +0b1111111111111111111111111111111111111111111111111011111111111111 15 +0b1111111111111111111111111111111111111111111111110111111111111111 16 +0b1111111111111111111111111111111111111111111111101111111111111111 17 +0b1111111111111111111111111111111111111111111111011111111111111111 18 +0b1111111111111111111111111111111111111111111110111111111111111111 19 +0b1111111111111111111111111111111111111111111101111111111111111111 20 +0b1111111111111111111111111111111111111111111011111111111111111111 21 +0b1111111111111111111111111111111111111111110111111111111111111111 22 +0b1111111111111111111111111111111111111111101111111111111111111111 23 +0b1111111111111111111111111111111111111111011111111111111111111111 24 +0b1111111111111111111111111111111111111110111111111111111111111111 25 +0b1111111111111111111111111111111111111101111111111111111111111111 26 +0b1111111111111111111111111111111111111011111111111111111111111111 27 +0b1111111111111111111111111111111111110111111111111111111111111111 28 +0b1111111111111111111111111111111111101111111111111111111111111111 29 +0b1111111111111111111111111111111111011111111111111111111111111111 30 +0b1111111111111111111111111111111110111111111111111111111111111111 31 +0b1111111111111111111111111111111101111111111111111111111111111111 32 +0b1111111111111111111111111111111011111111111111111111111111111111 33 +0b1111111111111111111111111111110111111111111111111111111111111111 34 +0b1111111111111111111111111111101111111111111111111111111111111111 35 +0b1111111111111111111111111111011111111111111111111111111111111111 36 +0b1111111111111111111111111110111111111111111111111111111111111111 37 +0b1111111111111111111111111101111111111111111111111111111111111111 38 +0b1111111111111111111111111011111111111111111111111111111111111111 39 +0b1111111111111111111111110111111111111111111111111111111111111111 40 +0b1111111111111111111111101111111111111111111111111111111111111111 41 +0b1111111111111111111111011111111111111111111111111111111111111111 42 +0b1111111111111111111110111111111111111111111111111111111111111111 43 +0b1111111111111111111101111111111111111111111111111111111111111111 44 +0b1111111111111111111011111111111111111111111111111111111111111111 45 +0b1111111111111111110111111111111111111111111111111111111111111111 46 +0b1111111111111111101111111111111111111111111111111111111111111111 47 +0b1111111111111111011111111111111111111111111111111111111111111111 48 +0b1111111111111110111111111111111111111111111111111111111111111111 49 +0b1111111111111101111111111111111111111111111111111111111111111111 50 +0b1111111111111011111111111111111111111111111111111111111111111111 51 +0b1111111111110111111111111111111111111111111111111111111111111111 52 +0b1111111111101111111111111111111111111111111111111111111111111111 53 +0b1111111111011111111111111111111111111111111111111111111111111111 54 +0b1111111110111111111111111111111111111111111111111111111111111111 55 +0b1111111101111111111111111111111111111111111111111111111111111111 56 +0b1111111011111111111111111111111111111111111111111111111111111111 57 +0b1111110111111111111111111111111111111111111111111111111111111111 58 +0b1111101111111111111111111111111111111111111111111111111111111111 59 +0b1111011111111111111111111111111111111111111111111111111111111111 60 +0b1110111111111111111111111111111111111111111111111111111111111111 61 +0b1101111111111111111111111111111111111111111111111111111111111111 62 +0b1011111111111111111111111111111111111111111111111111111111111111 63 +0b0111111111111111111111111111111111111111111111111111111111111111 64 + + +high1 + +signed char +0b00000000 0 +0b00000001 1 +0b00000010 2 +0b00000100 3 +0b00001000 4 +0b00010000 5 +0b00100000 6 +0b01000000 7 +0b10000000 8 + +unsigned char +0b00000000 0 +0b00000001 1 +0b00000010 2 +0b00000100 3 +0b00001000 4 +0b00010000 5 +0b00100000 6 +0b01000000 7 +0b10000000 8 + +short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000010 2 +0b0000000000000100 3 +0b0000000000001000 4 +0b0000000000010000 5 +0b0000000000100000 6 +0b0000000001000000 7 +0b0000000010000000 8 +0b0000000100000000 9 +0b0000001000000000 10 +0b0000010000000000 11 +0b0000100000000000 12 +0b0001000000000000 13 +0b0010000000000000 14 +0b0100000000000000 15 +0b1000000000000000 16 + +unsigned short int +0b0000000000000000 0 +0b0000000000000001 1 +0b0000000000000010 2 +0b0000000000000100 3 +0b0000000000001000 4 +0b0000000000010000 5 +0b0000000000100000 6 +0b0000000001000000 7 +0b0000000010000000 8 +0b0000000100000000 9 +0b0000001000000000 10 +0b0000010000000000 11 +0b0000100000000000 12 +0b0001000000000000 13 +0b0010000000000000 14 +0b0100000000000000 15 +0b1000000000000000 16 + +int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +unsigned int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +long int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +unsigned long int +0b00000000000000000000000000000000 0 +0b00000000000000000000000000000001 1 +0b00000000000000000000000000000010 2 +0b00000000000000000000000000000100 3 +0b00000000000000000000000000001000 4 +0b00000000000000000000000000010000 5 +0b00000000000000000000000000100000 6 +0b00000000000000000000000001000000 7 +0b00000000000000000000000010000000 8 +0b00000000000000000000000100000000 9 +0b00000000000000000000001000000000 10 +0b00000000000000000000010000000000 11 +0b00000000000000000000100000000000 12 +0b00000000000000000001000000000000 13 +0b00000000000000000010000000000000 14 +0b00000000000000000100000000000000 15 +0b00000000000000001000000000000000 16 +0b00000000000000010000000000000000 17 +0b00000000000000100000000000000000 18 +0b00000000000001000000000000000000 19 +0b00000000000010000000000000000000 20 +0b00000000000100000000000000000000 21 +0b00000000001000000000000000000000 22 +0b00000000010000000000000000000000 23 +0b00000000100000000000000000000000 24 +0b00000001000000000000000000000000 25 +0b00000010000000000000000000000000 26 +0b00000100000000000000000000000000 27 +0b00001000000000000000000000000000 28 +0b00010000000000000000000000000000 29 +0b00100000000000000000000000000000 30 +0b01000000000000000000000000000000 31 +0b10000000000000000000000000000000 32 + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 0 +0b0000000000000000000000000000000000000000000000000000000000000001 1 +0b0000000000000000000000000000000000000000000000000000000000000010 2 +0b0000000000000000000000000000000000000000000000000000000000000100 3 +0b0000000000000000000000000000000000000000000000000000000000001000 4 +0b0000000000000000000000000000000000000000000000000000000000010000 5 +0b0000000000000000000000000000000000000000000000000000000000100000 6 +0b0000000000000000000000000000000000000000000000000000000001000000 7 +0b0000000000000000000000000000000000000000000000000000000010000000 8 +0b0000000000000000000000000000000000000000000000000000000100000000 9 +0b0000000000000000000000000000000000000000000000000000001000000000 10 +0b0000000000000000000000000000000000000000000000000000010000000000 11 +0b0000000000000000000000000000000000000000000000000000100000000000 12 +0b0000000000000000000000000000000000000000000000000001000000000000 13 +0b0000000000000000000000000000000000000000000000000010000000000000 14 +0b0000000000000000000000000000000000000000000000000100000000000000 15 +0b0000000000000000000000000000000000000000000000001000000000000000 16 +0b0000000000000000000000000000000000000000000000010000000000000000 17 +0b0000000000000000000000000000000000000000000000100000000000000000 18 +0b0000000000000000000000000000000000000000000001000000000000000000 19 +0b0000000000000000000000000000000000000000000010000000000000000000 20 +0b0000000000000000000000000000000000000000000100000000000000000000 21 +0b0000000000000000000000000000000000000000001000000000000000000000 22 +0b0000000000000000000000000000000000000000010000000000000000000000 23 +0b0000000000000000000000000000000000000000100000000000000000000000 24 +0b0000000000000000000000000000000000000001000000000000000000000000 25 +0b0000000000000000000000000000000000000010000000000000000000000000 26 +0b0000000000000000000000000000000000000100000000000000000000000000 27 +0b0000000000000000000000000000000000001000000000000000000000000000 28 +0b0000000000000000000000000000000000010000000000000000000000000000 29 +0b0000000000000000000000000000000000100000000000000000000000000000 30 +0b0000000000000000000000000000000001000000000000000000000000000000 31 +0b0000000000000000000000000000000010000000000000000000000000000000 32 +0b0000000000000000000000000000000100000000000000000000000000000000 33 +0b0000000000000000000000000000001000000000000000000000000000000000 34 +0b0000000000000000000000000000010000000000000000000000000000000000 35 +0b0000000000000000000000000000100000000000000000000000000000000000 36 +0b0000000000000000000000000001000000000000000000000000000000000000 37 +0b0000000000000000000000000010000000000000000000000000000000000000 38 +0b0000000000000000000000000100000000000000000000000000000000000000 39 +0b0000000000000000000000001000000000000000000000000000000000000000 40 +0b0000000000000000000000010000000000000000000000000000000000000000 41 +0b0000000000000000000000100000000000000000000000000000000000000000 42 +0b0000000000000000000001000000000000000000000000000000000000000000 43 +0b0000000000000000000010000000000000000000000000000000000000000000 44 +0b0000000000000000000100000000000000000000000000000000000000000000 45 +0b0000000000000000001000000000000000000000000000000000000000000000 46 +0b0000000000000000010000000000000000000000000000000000000000000000 47 +0b0000000000000000100000000000000000000000000000000000000000000000 48 +0b0000000000000001000000000000000000000000000000000000000000000000 49 +0b0000000000000010000000000000000000000000000000000000000000000000 50 +0b0000000000000100000000000000000000000000000000000000000000000000 51 +0b0000000000001000000000000000000000000000000000000000000000000000 52 +0b0000000000010000000000000000000000000000000000000000000000000000 53 +0b0000000000100000000000000000000000000000000000000000000000000000 54 +0b0000000001000000000000000000000000000000000000000000000000000000 55 +0b0000000010000000000000000000000000000000000000000000000000000000 56 +0b0000000100000000000000000000000000000000000000000000000000000000 57 +0b0000001000000000000000000000000000000000000000000000000000000000 58 +0b0000010000000000000000000000000000000000000000000000000000000000 59 +0b0000100000000000000000000000000000000000000000000000000000000000 60 +0b0001000000000000000000000000000000000000000000000000000000000000 61 +0b0010000000000000000000000000000000000000000000000000000000000000 62 +0b0100000000000000000000000000000000000000000000000000000000000000 63 +0b1000000000000000000000000000000000000000000000000000000000000000 64 + Index: tests/.expect/bitmanip3.x64.txt =================================================================== --- tests/.expect/bitmanip3.x64.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/.expect/bitmanip3.x64.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1985 @@ + +is_pow2 + +signed char +0b00000000 false 0b00001101 false +0b00000001 true 0b00001110 false +0b00000010 true 0b00001111 false +0b00000100 true 0b00010001 false +0b00001000 true 0b00010101 false +0b00010000 true 0b00011101 false +0b00100000 true 0b00101101 false +0b01000000 true 0b01001101 false +0b10000000 true 0b10001101 false + +unsigned char +0b00000000 false 0b00001101 false +0b00000001 true 0b00001110 false +0b00000010 true 0b00001111 false +0b00000100 true 0b00010001 false +0b00001000 true 0b00010101 false +0b00010000 true 0b00011101 false +0b00100000 true 0b00101101 false +0b01000000 true 0b01001101 false +0b10000000 true 0b10001101 false + +short int +0b0000000000000000 false 0b0000000000001101 false +0b0000000000000001 true 0b0000000000001110 false +0b0000000000000010 true 0b0000000000001111 false +0b0000000000000100 true 0b0000000000010001 false +0b0000000000001000 true 0b0000000000010101 false +0b0000000000010000 true 0b0000000000011101 false +0b0000000000100000 true 0b0000000000101101 false +0b0000000001000000 true 0b0000000001001101 false +0b0000000010000000 true 0b0000000010001101 false +0b0000000100000000 true 0b0000000100001101 false +0b0000001000000000 true 0b0000001000001101 false +0b0000010000000000 true 0b0000010000001101 false +0b0000100000000000 true 0b0000100000001101 false +0b0001000000000000 true 0b0001000000001101 false +0b0010000000000000 true 0b0010000000001101 false +0b0100000000000000 true 0b0100000000001101 false +0b1000000000000000 true 0b1000000000001101 false + +unsigned short int +0b0000000000000000 false 0b0000000000001101 false +0b0000000000000001 true 0b0000000000001110 false +0b0000000000000010 true 0b0000000000001111 false +0b0000000000000100 true 0b0000000000010001 false +0b0000000000001000 true 0b0000000000010101 false +0b0000000000010000 true 0b0000000000011101 false +0b0000000000100000 true 0b0000000000101101 false +0b0000000001000000 true 0b0000000001001101 false +0b0000000010000000 true 0b0000000010001101 false +0b0000000100000000 true 0b0000000100001101 false +0b0000001000000000 true 0b0000001000001101 false +0b0000010000000000 true 0b0000010000001101 false +0b0000100000000000 true 0b0000100000001101 false +0b0001000000000000 true 0b0001000000001101 false +0b0010000000000000 true 0b0010000000001101 false +0b0100000000000000 true 0b0100000000001101 false +0b1000000000000000 true 0b1000000000001101 false + +int +0b00000000000000000000000000000000 false 0b00000000000000000000000000001101 false +0b00000000000000000000000000000001 true 0b00000000000000000000000000001110 false +0b00000000000000000000000000000010 true 0b00000000000000000000000000001111 false +0b00000000000000000000000000000100 true 0b00000000000000000000000000010001 false +0b00000000000000000000000000001000 true 0b00000000000000000000000000010101 false +0b00000000000000000000000000010000 true 0b00000000000000000000000000011101 false +0b00000000000000000000000000100000 true 0b00000000000000000000000000101101 false +0b00000000000000000000000001000000 true 0b00000000000000000000000001001101 false +0b00000000000000000000000010000000 true 0b00000000000000000000000010001101 false +0b00000000000000000000000100000000 true 0b00000000000000000000000100001101 false +0b00000000000000000000001000000000 true 0b00000000000000000000001000001101 false +0b00000000000000000000010000000000 true 0b00000000000000000000010000001101 false +0b00000000000000000000100000000000 true 0b00000000000000000000100000001101 false +0b00000000000000000001000000000000 true 0b00000000000000000001000000001101 false +0b00000000000000000010000000000000 true 0b00000000000000000010000000001101 false +0b00000000000000000100000000000000 true 0b00000000000000000100000000001101 false +0b00000000000000001000000000000000 true 0b00000000000000001000000000001101 false +0b00000000000000010000000000000000 true 0b00000000000000010000000000001101 false +0b00000000000000100000000000000000 true 0b00000000000000100000000000001101 false +0b00000000000001000000000000000000 true 0b00000000000001000000000000001101 false +0b00000000000010000000000000000000 true 0b00000000000010000000000000001101 false +0b00000000000100000000000000000000 true 0b00000000000100000000000000001101 false +0b00000000001000000000000000000000 true 0b00000000001000000000000000001101 false +0b00000000010000000000000000000000 true 0b00000000010000000000000000001101 false +0b00000000100000000000000000000000 true 0b00000000100000000000000000001101 false +0b00000001000000000000000000000000 true 0b00000001000000000000000000001101 false +0b00000010000000000000000000000000 true 0b00000010000000000000000000001101 false +0b00000100000000000000000000000000 true 0b00000100000000000000000000001101 false +0b00001000000000000000000000000000 true 0b00001000000000000000000000001101 false +0b00010000000000000000000000000000 true 0b00010000000000000000000000001101 false +0b00100000000000000000000000000000 true 0b00100000000000000000000000001101 false +0b01000000000000000000000000000000 true 0b01000000000000000000000000001101 false +0b10000000000000000000000000000000 true 0b10000000000000000000000000001101 false + +unsigned int +0b00000000000000000000000000000000 false 0b00000000000000000000000000001101 false +0b00000000000000000000000000000001 true 0b00000000000000000000000000001110 false +0b00000000000000000000000000000010 true 0b00000000000000000000000000001111 false +0b00000000000000000000000000000100 true 0b00000000000000000000000000010001 false +0b00000000000000000000000000001000 true 0b00000000000000000000000000010101 false +0b00000000000000000000000000010000 true 0b00000000000000000000000000011101 false +0b00000000000000000000000000100000 true 0b00000000000000000000000000101101 false +0b00000000000000000000000001000000 true 0b00000000000000000000000001001101 false +0b00000000000000000000000010000000 true 0b00000000000000000000000010001101 false +0b00000000000000000000000100000000 true 0b00000000000000000000000100001101 false +0b00000000000000000000001000000000 true 0b00000000000000000000001000001101 false +0b00000000000000000000010000000000 true 0b00000000000000000000010000001101 false +0b00000000000000000000100000000000 true 0b00000000000000000000100000001101 false +0b00000000000000000001000000000000 true 0b00000000000000000001000000001101 false +0b00000000000000000010000000000000 true 0b00000000000000000010000000001101 false +0b00000000000000000100000000000000 true 0b00000000000000000100000000001101 false +0b00000000000000001000000000000000 true 0b00000000000000001000000000001101 false +0b00000000000000010000000000000000 true 0b00000000000000010000000000001101 false +0b00000000000000100000000000000000 true 0b00000000000000100000000000001101 false +0b00000000000001000000000000000000 true 0b00000000000001000000000000001101 false +0b00000000000010000000000000000000 true 0b00000000000010000000000000001101 false +0b00000000000100000000000000000000 true 0b00000000000100000000000000001101 false +0b00000000001000000000000000000000 true 0b00000000001000000000000000001101 false +0b00000000010000000000000000000000 true 0b00000000010000000000000000001101 false +0b00000000100000000000000000000000 true 0b00000000100000000000000000001101 false +0b00000001000000000000000000000000 true 0b00000001000000000000000000001101 false +0b00000010000000000000000000000000 true 0b00000010000000000000000000001101 false +0b00000100000000000000000000000000 true 0b00000100000000000000000000001101 false +0b00001000000000000000000000000000 true 0b00001000000000000000000000001101 false +0b00010000000000000000000000000000 true 0b00010000000000000000000000001101 false +0b00100000000000000000000000000000 true 0b00100000000000000000000000001101 false +0b01000000000000000000000000000000 true 0b01000000000000000000000000001101 false +0b10000000000000000000000000000000 true 0b10000000000000000000000000001101 false + +long int +0b0000000000000000000000000000000000000000000000000000000000000000 false 0b0000000000000000000000000000000000000000000000000000000000001101 false +0b0000000000000000000000000000000000000000000000000000000000000001 true 0b0000000000000000000000000000000000000000000000000000000000001110 false +0b0000000000000000000000000000000000000000000000000000000000000010 true 0b0000000000000000000000000000000000000000000000000000000000001111 false +0b0000000000000000000000000000000000000000000000000000000000000100 true 0b0000000000000000000000000000000000000000000000000000000000010001 false +0b0000000000000000000000000000000000000000000000000000000000001000 true 0b0000000000000000000000000000000000000000000000000000000000010101 false +0b0000000000000000000000000000000000000000000000000000000000010000 true 0b0000000000000000000000000000000000000000000000000000000000011101 false +0b0000000000000000000000000000000000000000000000000000000000100000 true 0b0000000000000000000000000000000000000000000000000000000000101101 false +0b0000000000000000000000000000000000000000000000000000000001000000 true 0b0000000000000000000000000000000000000000000000000000000001001101 false +0b0000000000000000000000000000000000000000000000000000000010000000 true 0b0000000000000000000000000000000000000000000000000000000010001101 false +0b0000000000000000000000000000000000000000000000000000000100000000 true 0b0000000000000000000000000000000000000000000000000000000100001101 false +0b0000000000000000000000000000000000000000000000000000001000000000 true 0b0000000000000000000000000000000000000000000000000000001000001101 false +0b0000000000000000000000000000000000000000000000000000010000000000 true 0b0000000000000000000000000000000000000000000000000000010000001101 false +0b0000000000000000000000000000000000000000000000000000100000000000 true 0b0000000000000000000000000000000000000000000000000000100000001101 false +0b0000000000000000000000000000000000000000000000000001000000000000 true 0b0000000000000000000000000000000000000000000000000001000000001101 false +0b0000000000000000000000000000000000000000000000000010000000000000 true 0b0000000000000000000000000000000000000000000000000010000000001101 false +0b0000000000000000000000000000000000000000000000000100000000000000 true 0b0000000000000000000000000000000000000000000000000100000000001101 false +0b0000000000000000000000000000000000000000000000001000000000000000 true 0b0000000000000000000000000000000000000000000000001000000000001101 false +0b0000000000000000000000000000000000000000000000010000000000000000 true 0b0000000000000000000000000000000000000000000000010000000000001101 false +0b0000000000000000000000000000000000000000000000100000000000000000 true 0b0000000000000000000000000000000000000000000000100000000000001101 false +0b0000000000000000000000000000000000000000000001000000000000000000 true 0b0000000000000000000000000000000000000000000001000000000000001101 false +0b0000000000000000000000000000000000000000000010000000000000000000 true 0b0000000000000000000000000000000000000000000010000000000000001101 false +0b0000000000000000000000000000000000000000000100000000000000000000 true 0b0000000000000000000000000000000000000000000100000000000000001101 false +0b0000000000000000000000000000000000000000001000000000000000000000 true 0b0000000000000000000000000000000000000000001000000000000000001101 false +0b0000000000000000000000000000000000000000010000000000000000000000 true 0b0000000000000000000000000000000000000000010000000000000000001101 false +0b0000000000000000000000000000000000000000100000000000000000000000 true 0b0000000000000000000000000000000000000000100000000000000000001101 false +0b0000000000000000000000000000000000000001000000000000000000000000 true 0b0000000000000000000000000000000000000001000000000000000000001101 false +0b0000000000000000000000000000000000000010000000000000000000000000 true 0b0000000000000000000000000000000000000010000000000000000000001101 false +0b0000000000000000000000000000000000000100000000000000000000000000 true 0b0000000000000000000000000000000000000100000000000000000000001101 false +0b0000000000000000000000000000000000001000000000000000000000000000 true 0b0000000000000000000000000000000000001000000000000000000000001101 false +0b0000000000000000000000000000000000010000000000000000000000000000 true 0b0000000000000000000000000000000000010000000000000000000000001101 false +0b0000000000000000000000000000000000100000000000000000000000000000 true 0b0000000000000000000000000000000000100000000000000000000000001101 false +0b0000000000000000000000000000000001000000000000000000000000000000 true 0b0000000000000000000000000000000001000000000000000000000000001101 false +0b0000000000000000000000000000000010000000000000000000000000000000 true 0b0000000000000000000000000000000010000000000000000000000000001101 false +0b0000000000000000000000000000000100000000000000000000000000000000 true 0b0000000000000000000000000000000100000000000000000000000000001101 false +0b0000000000000000000000000000001000000000000000000000000000000000 true 0b0000000000000000000000000000001000000000000000000000000000001101 false +0b0000000000000000000000000000010000000000000000000000000000000000 true 0b0000000000000000000000000000010000000000000000000000000000001101 false +0b0000000000000000000000000000100000000000000000000000000000000000 true 0b0000000000000000000000000000100000000000000000000000000000001101 false +0b0000000000000000000000000001000000000000000000000000000000000000 true 0b0000000000000000000000000001000000000000000000000000000000001101 false +0b0000000000000000000000000010000000000000000000000000000000000000 true 0b0000000000000000000000000010000000000000000000000000000000001101 false +0b0000000000000000000000000100000000000000000000000000000000000000 true 0b0000000000000000000000000100000000000000000000000000000000001101 false +0b0000000000000000000000001000000000000000000000000000000000000000 true 0b0000000000000000000000001000000000000000000000000000000000001101 false +0b0000000000000000000000010000000000000000000000000000000000000000 true 0b0000000000000000000000010000000000000000000000000000000000001101 false +0b0000000000000000000000100000000000000000000000000000000000000000 true 0b0000000000000000000000100000000000000000000000000000000000001101 false +0b0000000000000000000001000000000000000000000000000000000000000000 true 0b0000000000000000000001000000000000000000000000000000000000001101 false +0b0000000000000000000010000000000000000000000000000000000000000000 true 0b0000000000000000000010000000000000000000000000000000000000001101 false +0b0000000000000000000100000000000000000000000000000000000000000000 true 0b0000000000000000000100000000000000000000000000000000000000001101 false +0b0000000000000000001000000000000000000000000000000000000000000000 true 0b0000000000000000001000000000000000000000000000000000000000001101 false +0b0000000000000000010000000000000000000000000000000000000000000000 true 0b0000000000000000010000000000000000000000000000000000000000001101 false +0b0000000000000000100000000000000000000000000000000000000000000000 true 0b0000000000000000100000000000000000000000000000000000000000001101 false +0b0000000000000001000000000000000000000000000000000000000000000000 true 0b0000000000000001000000000000000000000000000000000000000000001101 false +0b0000000000000010000000000000000000000000000000000000000000000000 true 0b0000000000000010000000000000000000000000000000000000000000001101 false +0b0000000000000100000000000000000000000000000000000000000000000000 true 0b0000000000000100000000000000000000000000000000000000000000001101 false +0b0000000000001000000000000000000000000000000000000000000000000000 true 0b0000000000001000000000000000000000000000000000000000000000001101 false +0b0000000000010000000000000000000000000000000000000000000000000000 true 0b0000000000010000000000000000000000000000000000000000000000001101 false +0b0000000000100000000000000000000000000000000000000000000000000000 true 0b0000000000100000000000000000000000000000000000000000000000001101 false +0b0000000001000000000000000000000000000000000000000000000000000000 true 0b0000000001000000000000000000000000000000000000000000000000001101 false +0b0000000010000000000000000000000000000000000000000000000000000000 true 0b0000000010000000000000000000000000000000000000000000000000001101 false +0b0000000100000000000000000000000000000000000000000000000000000000 true 0b0000000100000000000000000000000000000000000000000000000000001101 false +0b0000001000000000000000000000000000000000000000000000000000000000 true 0b0000001000000000000000000000000000000000000000000000000000001101 false +0b0000010000000000000000000000000000000000000000000000000000000000 true 0b0000010000000000000000000000000000000000000000000000000000001101 false +0b0000100000000000000000000000000000000000000000000000000000000000 true 0b0000100000000000000000000000000000000000000000000000000000001101 false +0b0001000000000000000000000000000000000000000000000000000000000000 true 0b0001000000000000000000000000000000000000000000000000000000001101 false +0b0010000000000000000000000000000000000000000000000000000000000000 true 0b0010000000000000000000000000000000000000000000000000000000001101 false +0b0100000000000000000000000000000000000000000000000000000000000000 true 0b0100000000000000000000000000000000000000000000000000000000001101 false +0b1000000000000000000000000000000000000000000000000000000000000000 true 0b1000000000000000000000000000000000000000000000000000000000001101 false + +unsigned long int +0b0000000000000000000000000000000000000000000000000000000000000000 false 0b0000000000000000000000000000000000000000000000000000000000001101 false +0b0000000000000000000000000000000000000000000000000000000000000001 true 0b0000000000000000000000000000000000000000000000000000000000001110 false +0b0000000000000000000000000000000000000000000000000000000000000010 true 0b0000000000000000000000000000000000000000000000000000000000001111 false +0b0000000000000000000000000000000000000000000000000000000000000100 true 0b0000000000000000000000000000000000000000000000000000000000010001 false +0b0000000000000000000000000000000000000000000000000000000000001000 true 0b0000000000000000000000000000000000000000000000000000000000010101 false +0b0000000000000000000000000000000000000000000000000000000000010000 true 0b0000000000000000000000000000000000000000000000000000000000011101 false +0b0000000000000000000000000000000000000000000000000000000000100000 true 0b0000000000000000000000000000000000000000000000000000000000101101 false +0b0000000000000000000000000000000000000000000000000000000001000000 true 0b0000000000000000000000000000000000000000000000000000000001001101 false +0b0000000000000000000000000000000000000000000000000000000010000000 true 0b0000000000000000000000000000000000000000000000000000000010001101 false +0b0000000000000000000000000000000000000000000000000000000100000000 true 0b0000000000000000000000000000000000000000000000000000000100001101 false +0b0000000000000000000000000000000000000000000000000000001000000000 true 0b0000000000000000000000000000000000000000000000000000001000001101 false +0b0000000000000000000000000000000000000000000000000000010000000000 true 0b0000000000000000000000000000000000000000000000000000010000001101 false +0b0000000000000000000000000000000000000000000000000000100000000000 true 0b0000000000000000000000000000000000000000000000000000100000001101 false +0b0000000000000000000000000000000000000000000000000001000000000000 true 0b0000000000000000000000000000000000000000000000000001000000001101 false +0b0000000000000000000000000000000000000000000000000010000000000000 true 0b0000000000000000000000000000000000000000000000000010000000001101 false +0b0000000000000000000000000000000000000000000000000100000000000000 true 0b0000000000000000000000000000000000000000000000000100000000001101 false +0b0000000000000000000000000000000000000000000000001000000000000000 true 0b0000000000000000000000000000000000000000000000001000000000001101 false +0b0000000000000000000000000000000000000000000000010000000000000000 true 0b0000000000000000000000000000000000000000000000010000000000001101 false +0b0000000000000000000000000000000000000000000000100000000000000000 true 0b0000000000000000000000000000000000000000000000100000000000001101 false +0b0000000000000000000000000000000000000000000001000000000000000000 true 0b0000000000000000000000000000000000000000000001000000000000001101 false +0b0000000000000000000000000000000000000000000010000000000000000000 true 0b0000000000000000000000000000000000000000000010000000000000001101 false +0b0000000000000000000000000000000000000000000100000000000000000000 true 0b0000000000000000000000000000000000000000000100000000000000001101 false +0b0000000000000000000000000000000000000000001000000000000000000000 true 0b0000000000000000000000000000000000000000001000000000000000001101 false +0b0000000000000000000000000000000000000000010000000000000000000000 true 0b0000000000000000000000000000000000000000010000000000000000001101 false +0b0000000000000000000000000000000000000000100000000000000000000000 true 0b0000000000000000000000000000000000000000100000000000000000001101 false +0b0000000000000000000000000000000000000001000000000000000000000000 true 0b0000000000000000000000000000000000000001000000000000000000001101 false +0b0000000000000000000000000000000000000010000000000000000000000000 true 0b0000000000000000000000000000000000000010000000000000000000001101 false +0b0000000000000000000000000000000000000100000000000000000000000000 true 0b0000000000000000000000000000000000000100000000000000000000001101 false +0b0000000000000000000000000000000000001000000000000000000000000000 true 0b0000000000000000000000000000000000001000000000000000000000001101 false +0b0000000000000000000000000000000000010000000000000000000000000000 true 0b0000000000000000000000000000000000010000000000000000000000001101 false +0b0000000000000000000000000000000000100000000000000000000000000000 true 0b0000000000000000000000000000000000100000000000000000000000001101 false +0b0000000000000000000000000000000001000000000000000000000000000000 true 0b0000000000000000000000000000000001000000000000000000000000001101 false +0b0000000000000000000000000000000010000000000000000000000000000000 true 0b0000000000000000000000000000000010000000000000000000000000001101 false +0b0000000000000000000000000000000100000000000000000000000000000000 true 0b0000000000000000000000000000000100000000000000000000000000001101 false +0b0000000000000000000000000000001000000000000000000000000000000000 true 0b0000000000000000000000000000001000000000000000000000000000001101 false +0b0000000000000000000000000000010000000000000000000000000000000000 true 0b0000000000000000000000000000010000000000000000000000000000001101 false +0b0000000000000000000000000000100000000000000000000000000000000000 true 0b0000000000000000000000000000100000000000000000000000000000001101 false +0b0000000000000000000000000001000000000000000000000000000000000000 true 0b0000000000000000000000000001000000000000000000000000000000001101 false +0b0000000000000000000000000010000000000000000000000000000000000000 true 0b0000000000000000000000000010000000000000000000000000000000001101 false +0b0000000000000000000000000100000000000000000000000000000000000000 true 0b0000000000000000000000000100000000000000000000000000000000001101 false +0b0000000000000000000000001000000000000000000000000000000000000000 true 0b0000000000000000000000001000000000000000000000000000000000001101 false +0b0000000000000000000000010000000000000000000000000000000000000000 true 0b0000000000000000000000010000000000000000000000000000000000001101 false +0b0000000000000000000000100000000000000000000000000000000000000000 true 0b0000000000000000000000100000000000000000000000000000000000001101 false +0b0000000000000000000001000000000000000000000000000000000000000000 true 0b0000000000000000000001000000000000000000000000000000000000001101 false +0b0000000000000000000010000000000000000000000000000000000000000000 true 0b0000000000000000000010000000000000000000000000000000000000001101 false +0b0000000000000000000100000000000000000000000000000000000000000000 true 0b0000000000000000000100000000000000000000000000000000000000001101 false +0b0000000000000000001000000000000000000000000000000000000000000000 true 0b0000000000000000001000000000000000000000000000000000000000001101 false +0b0000000000000000010000000000000000000000000000000000000000000000 true 0b0000000000000000010000000000000000000000000000000000000000001101 false +0b0000000000000000100000000000000000000000000000000000000000000000 true 0b0000000000000000100000000000000000000000000000000000000000001101 false +0b0000000000000001000000000000000000000000000000000000000000000000 true 0b0000000000000001000000000000000000000000000000000000000000001101 false +0b0000000000000010000000000000000000000000000000000000000000000000 true 0b0000000000000010000000000000000000000000000000000000000000001101 false +0b0000000000000100000000000000000000000000000000000000000000000000 true 0b0000000000000100000000000000000000000000000000000000000000001101 false +0b0000000000001000000000000000000000000000000000000000000000000000 true 0b0000000000001000000000000000000000000000000000000000000000001101 false +0b0000000000010000000000000000000000000000000000000000000000000000 true 0b0000000000010000000000000000000000000000000000000000000000001101 false +0b0000000000100000000000000000000000000000000000000000000000000000 true 0b0000000000100000000000000000000000000000000000000000000000001101 false +0b0000000001000000000000000000000000000000000000000000000000000000 true 0b0000000001000000000000000000000000000000000000000000000000001101 false +0b0000000010000000000000000000000000000000000000000000000000000000 true 0b0000000010000000000000000000000000000000000000000000000000001101 false +0b0000000100000000000000000000000000000000000000000000000000000000 true 0b0000000100000000000000000000000000000000000000000000000000001101 false +0b0000001000000000000000000000000000000000000000000000000000000000 true 0b0000001000000000000000000000000000000000000000000000000000001101 false +0b0000010000000000000000000000000000000000000000000000000000000000 true 0b0000010000000000000000000000000000000000000000000000000000001101 false +0b0000100000000000000000000000000000000000000000000000000000000000 true 0b0000100000000000000000000000000000000000000000000000000000001101 false +0b0001000000000000000000000000000000000000000000000000000000000000 true 0b0001000000000000000000000000000000000000000000000000000000001101 false +0b0010000000000000000000000000000000000000000000000000000000000000 true 0b0010000000000000000000000000000000000000000000000000000000001101 false +0b0100000000000000000000000000000000000000000000000000000000000000 true 0b0100000000000000000000000000000000000000000000000000000000001101 false +0b1000000000000000000000000000000000000000000000000000000000000000 true 0b1000000000000000000000000000000000000000000000000000000000001101 false + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 false 0b0000000000000000000000000000000000000000000000000000000000001101 false +0b0000000000000000000000000000000000000000000000000000000000000001 true 0b0000000000000000000000000000000000000000000000000000000000001110 false +0b0000000000000000000000000000000000000000000000000000000000000010 true 0b0000000000000000000000000000000000000000000000000000000000001111 false +0b0000000000000000000000000000000000000000000000000000000000000100 true 0b0000000000000000000000000000000000000000000000000000000000010001 false +0b0000000000000000000000000000000000000000000000000000000000001000 true 0b0000000000000000000000000000000000000000000000000000000000010101 false +0b0000000000000000000000000000000000000000000000000000000000010000 true 0b0000000000000000000000000000000000000000000000000000000000011101 false +0b0000000000000000000000000000000000000000000000000000000000100000 true 0b0000000000000000000000000000000000000000000000000000000000101101 false +0b0000000000000000000000000000000000000000000000000000000001000000 true 0b0000000000000000000000000000000000000000000000000000000001001101 false +0b0000000000000000000000000000000000000000000000000000000010000000 true 0b0000000000000000000000000000000000000000000000000000000010001101 false +0b0000000000000000000000000000000000000000000000000000000100000000 true 0b0000000000000000000000000000000000000000000000000000000100001101 false +0b0000000000000000000000000000000000000000000000000000001000000000 true 0b0000000000000000000000000000000000000000000000000000001000001101 false +0b0000000000000000000000000000000000000000000000000000010000000000 true 0b0000000000000000000000000000000000000000000000000000010000001101 false +0b0000000000000000000000000000000000000000000000000000100000000000 true 0b0000000000000000000000000000000000000000000000000000100000001101 false +0b0000000000000000000000000000000000000000000000000001000000000000 true 0b0000000000000000000000000000000000000000000000000001000000001101 false +0b0000000000000000000000000000000000000000000000000010000000000000 true 0b0000000000000000000000000000000000000000000000000010000000001101 false +0b0000000000000000000000000000000000000000000000000100000000000000 true 0b0000000000000000000000000000000000000000000000000100000000001101 false +0b0000000000000000000000000000000000000000000000001000000000000000 true 0b0000000000000000000000000000000000000000000000001000000000001101 false +0b0000000000000000000000000000000000000000000000010000000000000000 true 0b0000000000000000000000000000000000000000000000010000000000001101 false +0b0000000000000000000000000000000000000000000000100000000000000000 true 0b0000000000000000000000000000000000000000000000100000000000001101 false +0b0000000000000000000000000000000000000000000001000000000000000000 true 0b0000000000000000000000000000000000000000000001000000000000001101 false +0b0000000000000000000000000000000000000000000010000000000000000000 true 0b0000000000000000000000000000000000000000000010000000000000001101 false +0b0000000000000000000000000000000000000000000100000000000000000000 true 0b0000000000000000000000000000000000000000000100000000000000001101 false +0b0000000000000000000000000000000000000000001000000000000000000000 true 0b0000000000000000000000000000000000000000001000000000000000001101 false +0b0000000000000000000000000000000000000000010000000000000000000000 true 0b0000000000000000000000000000000000000000010000000000000000001101 false +0b0000000000000000000000000000000000000000100000000000000000000000 true 0b0000000000000000000000000000000000000000100000000000000000001101 false +0b0000000000000000000000000000000000000001000000000000000000000000 true 0b0000000000000000000000000000000000000001000000000000000000001101 false +0b0000000000000000000000000000000000000010000000000000000000000000 true 0b0000000000000000000000000000000000000010000000000000000000001101 false +0b0000000000000000000000000000000000000100000000000000000000000000 true 0b0000000000000000000000000000000000000100000000000000000000001101 false +0b0000000000000000000000000000000000001000000000000000000000000000 true 0b0000000000000000000000000000000000001000000000000000000000001101 false +0b0000000000000000000000000000000000010000000000000000000000000000 true 0b0000000000000000000000000000000000010000000000000000000000001101 false +0b0000000000000000000000000000000000100000000000000000000000000000 true 0b0000000000000000000000000000000000100000000000000000000000001101 false +0b0000000000000000000000000000000001000000000000000000000000000000 true 0b0000000000000000000000000000000001000000000000000000000000001101 false +0b0000000000000000000000000000000010000000000000000000000000000000 true 0b0000000000000000000000000000000010000000000000000000000000001101 false +0b0000000000000000000000000000000100000000000000000000000000000000 true 0b0000000000000000000000000000000100000000000000000000000000001101 false +0b0000000000000000000000000000001000000000000000000000000000000000 true 0b0000000000000000000000000000001000000000000000000000000000001101 false +0b0000000000000000000000000000010000000000000000000000000000000000 true 0b0000000000000000000000000000010000000000000000000000000000001101 false +0b0000000000000000000000000000100000000000000000000000000000000000 true 0b0000000000000000000000000000100000000000000000000000000000001101 false +0b0000000000000000000000000001000000000000000000000000000000000000 true 0b0000000000000000000000000001000000000000000000000000000000001101 false +0b0000000000000000000000000010000000000000000000000000000000000000 true 0b0000000000000000000000000010000000000000000000000000000000001101 false +0b0000000000000000000000000100000000000000000000000000000000000000 true 0b0000000000000000000000000100000000000000000000000000000000001101 false +0b0000000000000000000000001000000000000000000000000000000000000000 true 0b0000000000000000000000001000000000000000000000000000000000001101 false +0b0000000000000000000000010000000000000000000000000000000000000000 true 0b0000000000000000000000010000000000000000000000000000000000001101 false +0b0000000000000000000000100000000000000000000000000000000000000000 true 0b0000000000000000000000100000000000000000000000000000000000001101 false +0b0000000000000000000001000000000000000000000000000000000000000000 true 0b0000000000000000000001000000000000000000000000000000000000001101 false +0b0000000000000000000010000000000000000000000000000000000000000000 true 0b0000000000000000000010000000000000000000000000000000000000001101 false +0b0000000000000000000100000000000000000000000000000000000000000000 true 0b0000000000000000000100000000000000000000000000000000000000001101 false +0b0000000000000000001000000000000000000000000000000000000000000000 true 0b0000000000000000001000000000000000000000000000000000000000001101 false +0b0000000000000000010000000000000000000000000000000000000000000000 true 0b0000000000000000010000000000000000000000000000000000000000001101 false +0b0000000000000000100000000000000000000000000000000000000000000000 true 0b0000000000000000100000000000000000000000000000000000000000001101 false +0b0000000000000001000000000000000000000000000000000000000000000000 true 0b0000000000000001000000000000000000000000000000000000000000001101 false +0b0000000000000010000000000000000000000000000000000000000000000000 true 0b0000000000000010000000000000000000000000000000000000000000001101 false +0b0000000000000100000000000000000000000000000000000000000000000000 true 0b0000000000000100000000000000000000000000000000000000000000001101 false +0b0000000000001000000000000000000000000000000000000000000000000000 true 0b0000000000001000000000000000000000000000000000000000000000001101 false +0b0000000000010000000000000000000000000000000000000000000000000000 true 0b0000000000010000000000000000000000000000000000000000000000001101 false +0b0000000000100000000000000000000000000000000000000000000000000000 true 0b0000000000100000000000000000000000000000000000000000000000001101 false +0b0000000001000000000000000000000000000000000000000000000000000000 true 0b0000000001000000000000000000000000000000000000000000000000001101 false +0b0000000010000000000000000000000000000000000000000000000000000000 true 0b0000000010000000000000000000000000000000000000000000000000001101 false +0b0000000100000000000000000000000000000000000000000000000000000000 true 0b0000000100000000000000000000000000000000000000000000000000001101 false +0b0000001000000000000000000000000000000000000000000000000000000000 true 0b0000001000000000000000000000000000000000000000000000000000001101 false +0b0000010000000000000000000000000000000000000000000000000000000000 true 0b0000010000000000000000000000000000000000000000000000000000001101 false +0b0000100000000000000000000000000000000000000000000000000000000000 true 0b0000100000000000000000000000000000000000000000000000000000001101 false +0b0001000000000000000000000000000000000000000000000000000000000000 true 0b0001000000000000000000000000000000000000000000000000000000001101 false +0b0010000000000000000000000000000000000000000000000000000000000000 true 0b0010000000000000000000000000000000000000000000000000000000001101 false +0b0100000000000000000000000000000000000000000000000000000000000000 true 0b0100000000000000000000000000000000000000000000000000000000001101 false +0b1000000000000000000000000000000000000000000000000000000000000000 true 0b1000000000000000000000000000000000000000000000000000000000001101 false + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 false 0b0000000000000000000000000000000000000000000000000000000000001101 false +0b0000000000000000000000000000000000000000000000000000000000000001 true 0b0000000000000000000000000000000000000000000000000000000000001110 false +0b0000000000000000000000000000000000000000000000000000000000000010 true 0b0000000000000000000000000000000000000000000000000000000000001111 false +0b0000000000000000000000000000000000000000000000000000000000000100 true 0b0000000000000000000000000000000000000000000000000000000000010001 false +0b0000000000000000000000000000000000000000000000000000000000001000 true 0b0000000000000000000000000000000000000000000000000000000000010101 false +0b0000000000000000000000000000000000000000000000000000000000010000 true 0b0000000000000000000000000000000000000000000000000000000000011101 false +0b0000000000000000000000000000000000000000000000000000000000100000 true 0b0000000000000000000000000000000000000000000000000000000000101101 false +0b0000000000000000000000000000000000000000000000000000000001000000 true 0b0000000000000000000000000000000000000000000000000000000001001101 false +0b0000000000000000000000000000000000000000000000000000000010000000 true 0b0000000000000000000000000000000000000000000000000000000010001101 false +0b0000000000000000000000000000000000000000000000000000000100000000 true 0b0000000000000000000000000000000000000000000000000000000100001101 false +0b0000000000000000000000000000000000000000000000000000001000000000 true 0b0000000000000000000000000000000000000000000000000000001000001101 false +0b0000000000000000000000000000000000000000000000000000010000000000 true 0b0000000000000000000000000000000000000000000000000000010000001101 false +0b0000000000000000000000000000000000000000000000000000100000000000 true 0b0000000000000000000000000000000000000000000000000000100000001101 false +0b0000000000000000000000000000000000000000000000000001000000000000 true 0b0000000000000000000000000000000000000000000000000001000000001101 false +0b0000000000000000000000000000000000000000000000000010000000000000 true 0b0000000000000000000000000000000000000000000000000010000000001101 false +0b0000000000000000000000000000000000000000000000000100000000000000 true 0b0000000000000000000000000000000000000000000000000100000000001101 false +0b0000000000000000000000000000000000000000000000001000000000000000 true 0b0000000000000000000000000000000000000000000000001000000000001101 false +0b0000000000000000000000000000000000000000000000010000000000000000 true 0b0000000000000000000000000000000000000000000000010000000000001101 false +0b0000000000000000000000000000000000000000000000100000000000000000 true 0b0000000000000000000000000000000000000000000000100000000000001101 false +0b0000000000000000000000000000000000000000000001000000000000000000 true 0b0000000000000000000000000000000000000000000001000000000000001101 false +0b0000000000000000000000000000000000000000000010000000000000000000 true 0b0000000000000000000000000000000000000000000010000000000000001101 false +0b0000000000000000000000000000000000000000000100000000000000000000 true 0b0000000000000000000000000000000000000000000100000000000000001101 false +0b0000000000000000000000000000000000000000001000000000000000000000 true 0b0000000000000000000000000000000000000000001000000000000000001101 false +0b0000000000000000000000000000000000000000010000000000000000000000 true 0b0000000000000000000000000000000000000000010000000000000000001101 false +0b0000000000000000000000000000000000000000100000000000000000000000 true 0b0000000000000000000000000000000000000000100000000000000000001101 false +0b0000000000000000000000000000000000000001000000000000000000000000 true 0b0000000000000000000000000000000000000001000000000000000000001101 false +0b0000000000000000000000000000000000000010000000000000000000000000 true 0b0000000000000000000000000000000000000010000000000000000000001101 false +0b0000000000000000000000000000000000000100000000000000000000000000 true 0b0000000000000000000000000000000000000100000000000000000000001101 false +0b0000000000000000000000000000000000001000000000000000000000000000 true 0b0000000000000000000000000000000000001000000000000000000000001101 false +0b0000000000000000000000000000000000010000000000000000000000000000 true 0b0000000000000000000000000000000000010000000000000000000000001101 false +0b0000000000000000000000000000000000100000000000000000000000000000 true 0b0000000000000000000000000000000000100000000000000000000000001101 false +0b0000000000000000000000000000000001000000000000000000000000000000 true 0b0000000000000000000000000000000001000000000000000000000000001101 false +0b0000000000000000000000000000000010000000000000000000000000000000 true 0b0000000000000000000000000000000010000000000000000000000000001101 false +0b0000000000000000000000000000000100000000000000000000000000000000 true 0b0000000000000000000000000000000100000000000000000000000000001101 false +0b0000000000000000000000000000001000000000000000000000000000000000 true 0b0000000000000000000000000000001000000000000000000000000000001101 false +0b0000000000000000000000000000010000000000000000000000000000000000 true 0b0000000000000000000000000000010000000000000000000000000000001101 false +0b0000000000000000000000000000100000000000000000000000000000000000 true 0b0000000000000000000000000000100000000000000000000000000000001101 false +0b0000000000000000000000000001000000000000000000000000000000000000 true 0b0000000000000000000000000001000000000000000000000000000000001101 false +0b0000000000000000000000000010000000000000000000000000000000000000 true 0b0000000000000000000000000010000000000000000000000000000000001101 false +0b0000000000000000000000000100000000000000000000000000000000000000 true 0b0000000000000000000000000100000000000000000000000000000000001101 false +0b0000000000000000000000001000000000000000000000000000000000000000 true 0b0000000000000000000000001000000000000000000000000000000000001101 false +0b0000000000000000000000010000000000000000000000000000000000000000 true 0b0000000000000000000000010000000000000000000000000000000000001101 false +0b0000000000000000000000100000000000000000000000000000000000000000 true 0b0000000000000000000000100000000000000000000000000000000000001101 false +0b0000000000000000000001000000000000000000000000000000000000000000 true 0b0000000000000000000001000000000000000000000000000000000000001101 false +0b0000000000000000000010000000000000000000000000000000000000000000 true 0b0000000000000000000010000000000000000000000000000000000000001101 false +0b0000000000000000000100000000000000000000000000000000000000000000 true 0b0000000000000000000100000000000000000000000000000000000000001101 false +0b0000000000000000001000000000000000000000000000000000000000000000 true 0b0000000000000000001000000000000000000000000000000000000000001101 false +0b0000000000000000010000000000000000000000000000000000000000000000 true 0b0000000000000000010000000000000000000000000000000000000000001101 false +0b0000000000000000100000000000000000000000000000000000000000000000 true 0b0000000000000000100000000000000000000000000000000000000000001101 false +0b0000000000000001000000000000000000000000000000000000000000000000 true 0b0000000000000001000000000000000000000000000000000000000000001101 false +0b0000000000000010000000000000000000000000000000000000000000000000 true 0b0000000000000010000000000000000000000000000000000000000000001101 false +0b0000000000000100000000000000000000000000000000000000000000000000 true 0b0000000000000100000000000000000000000000000000000000000000001101 false +0b0000000000001000000000000000000000000000000000000000000000000000 true 0b0000000000001000000000000000000000000000000000000000000000001101 false +0b0000000000010000000000000000000000000000000000000000000000000000 true 0b0000000000010000000000000000000000000000000000000000000000001101 false +0b0000000000100000000000000000000000000000000000000000000000000000 true 0b0000000000100000000000000000000000000000000000000000000000001101 false +0b0000000001000000000000000000000000000000000000000000000000000000 true 0b0000000001000000000000000000000000000000000000000000000000001101 false +0b0000000010000000000000000000000000000000000000000000000000000000 true 0b0000000010000000000000000000000000000000000000000000000000001101 false +0b0000000100000000000000000000000000000000000000000000000000000000 true 0b0000000100000000000000000000000000000000000000000000000000001101 false +0b0000001000000000000000000000000000000000000000000000000000000000 true 0b0000001000000000000000000000000000000000000000000000000000001101 false +0b0000010000000000000000000000000000000000000000000000000000000000 true 0b0000010000000000000000000000000000000000000000000000000000001101 false +0b0000100000000000000000000000000000000000000000000000000000000000 true 0b0000100000000000000000000000000000000000000000000000000000001101 false +0b0001000000000000000000000000000000000000000000000000000000000000 true 0b0001000000000000000000000000000000000000000000000000000000001101 false +0b0010000000000000000000000000000000000000000000000000000000000000 true 0b0010000000000000000000000000000000000000000000000000000000001101 false +0b0100000000000000000000000000000000000000000000000000000000000000 true 0b0100000000000000000000000000000000000000000000000000000000001101 false +0b1000000000000000000000000000000000000000000000000000000000000000 true 0b1000000000000000000000000000000000000000000000000000000000001101 false + + +floor2 + +signed char +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(-128, -128) = -128, floor2(-126, -128) = -128, floor2(126, -128) = 0 + +unsigned char +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(254, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(253, 1) = 253 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(252, 2) = 252 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(250, 4) = 248 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(246, 8) = 240 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(238, 16) = 224 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(222, 32) = 192 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(190, 64) = 128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(126, 128) = 0 + +short int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(-130, 128) = -256 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(-258, 256) = -512 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(-514, 512) = -1024 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(-1026, 1024) = -2048 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(-2050, 2048) = -4096 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(-4098, 4096) = -8192 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(-8194, 8192) = -16384 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(-16386, 16384) = -32768 +floor2(-32768, -32768) = -32768, floor2(-32766, -32768) = -32768, floor2(32766, -32768) = 0 + +unsigned short int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(65534, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(65533, 1) = 65533 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(65532, 2) = 65532 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(65530, 4) = 65528 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(65526, 8) = 65520 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(65518, 16) = 65504 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(65502, 32) = 65472 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(65470, 64) = 65408 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(65406, 128) = 65280 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(65278, 256) = 65024 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(65022, 512) = 64512 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(64510, 1024) = 63488 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(63486, 2048) = 61440 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(61438, 4096) = 57344 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(57342, 8192) = 49152 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(49150, 16384) = 32768 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(32766, 32768) = 0 + +int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(-130, 128) = -256 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(-258, 256) = -512 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(-514, 512) = -1024 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(-1026, 1024) = -2048 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(-2050, 2048) = -4096 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(-4098, 4096) = -8192 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(-8194, 8192) = -16384 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(-16386, 16384) = -32768 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(-32770, 32768) = -65536 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(-65538, 65536) = -131072 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(-131074, 131072) = -262144 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(-262146, 262144) = -524288 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(-524290, 524288) = -1048576 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(-1048578, 1048576) = -2097152 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(-2097154, 2097152) = -4194304 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(-4194306, 4194304) = -8388608 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(-8388610, 8388608) = -16777216 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(-16777218, 16777216) = -33554432 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(-33554434, 33554432) = -67108864 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(-67108866, 67108864) = -134217728 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(-134217730, 134217728) = -268435456 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(-268435458, 268435456) = -536870912 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(-536870914, 536870912) = -1073741824 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(-1073741826, 1073741824) = -2147483648 +floor2(-2147483648, -2147483648) = -2147483648, floor2(-2147483646, -2147483648) = -2147483648, floor2(2147483646, -2147483648) = 0 + +unsigned int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(4294967294, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(4294967293, 1) = 4294967293 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(4294967292, 2) = 4294967292 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(4294967290, 4) = 4294967288 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(4294967286, 8) = 4294967280 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(4294967278, 16) = 4294967264 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(4294967262, 32) = 4294967232 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(4294967230, 64) = 4294967168 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(4294967166, 128) = 4294967040 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(4294967038, 256) = 4294966784 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(4294966782, 512) = 4294966272 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(4294966270, 1024) = 4294965248 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(4294965246, 2048) = 4294963200 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(4294963198, 4096) = 4294959104 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(4294959102, 8192) = 4294950912 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(4294950910, 16384) = 4294934528 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(4294934526, 32768) = 4294901760 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(4294901758, 65536) = 4294836224 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(4294836222, 131072) = 4294705152 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(4294705150, 262144) = 4294443008 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(4294443006, 524288) = 4293918720 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(4293918718, 1048576) = 4292870144 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(4292870142, 2097152) = 4290772992 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(4290772990, 4194304) = 4286578688 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(4286578686, 8388608) = 4278190080 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(4278190078, 16777216) = 4261412864 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(4261412862, 33554432) = 4227858432 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(4227858430, 67108864) = 4160749568 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(4160749566, 134217728) = 4026531840 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(4026531838, 268435456) = 3758096384 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(3758096382, 536870912) = 3221225472 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(3221225470, 1073741824) = 2147483648 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(2147483646, 2147483648) = 0 + +long int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(-130, 128) = -256 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(-258, 256) = -512 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(-514, 512) = -1024 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(-1026, 1024) = -2048 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(-2050, 2048) = -4096 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(-4098, 4096) = -8192 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(-8194, 8192) = -16384 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(-16386, 16384) = -32768 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(-32770, 32768) = -65536 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(-65538, 65536) = -131072 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(-131074, 131072) = -262144 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(-262146, 262144) = -524288 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(-524290, 524288) = -1048576 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(-1048578, 1048576) = -2097152 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(-2097154, 2097152) = -4194304 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(-4194306, 4194304) = -8388608 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(-8388610, 8388608) = -16777216 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(-16777218, 16777216) = -33554432 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(-33554434, 33554432) = -67108864 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(-67108866, 67108864) = -134217728 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(-134217730, 134217728) = -268435456 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(-268435458, 268435456) = -536870912 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(-536870914, 536870912) = -1073741824 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(-1073741826, 1073741824) = -2147483648 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(-2147483650, 2147483648) = -4294967296 +floor2(4294967296, 4294967296) = 4294967296, floor2(4294967298, 4294967296) = 4294967296, floor2(-4294967298, 4294967296) = -8589934592 +floor2(8589934592, 8589934592) = 8589934592, floor2(8589934594, 8589934592) = 8589934592, floor2(-8589934594, 8589934592) = -17179869184 +floor2(17179869184, 17179869184) = 17179869184, floor2(17179869186, 17179869184) = 17179869184, floor2(-17179869186, 17179869184) = -34359738368 +floor2(34359738368, 34359738368) = 34359738368, floor2(34359738370, 34359738368) = 34359738368, floor2(-34359738370, 34359738368) = -68719476736 +floor2(68719476736, 68719476736) = 68719476736, floor2(68719476738, 68719476736) = 68719476736, floor2(-68719476738, 68719476736) = -137438953472 +floor2(137438953472, 137438953472) = 137438953472, floor2(137438953474, 137438953472) = 137438953472, floor2(-137438953474, 137438953472) = -274877906944 +floor2(274877906944, 274877906944) = 274877906944, floor2(274877906946, 274877906944) = 274877906944, floor2(-274877906946, 274877906944) = -549755813888 +floor2(549755813888, 549755813888) = 549755813888, floor2(549755813890, 549755813888) = 549755813888, floor2(-549755813890, 549755813888) = -1099511627776 +floor2(1099511627776, 1099511627776) = 1099511627776, floor2(1099511627778, 1099511627776) = 1099511627776, floor2(-1099511627778, 1099511627776) = -2199023255552 +floor2(2199023255552, 2199023255552) = 2199023255552, floor2(2199023255554, 2199023255552) = 2199023255552, floor2(-2199023255554, 2199023255552) = -4398046511104 +floor2(4398046511104, 4398046511104) = 4398046511104, floor2(4398046511106, 4398046511104) = 4398046511104, floor2(-4398046511106, 4398046511104) = -8796093022208 +floor2(8796093022208, 8796093022208) = 8796093022208, floor2(8796093022210, 8796093022208) = 8796093022208, floor2(-8796093022210, 8796093022208) = -17592186044416 +floor2(17592186044416, 17592186044416) = 17592186044416, floor2(17592186044418, 17592186044416) = 17592186044416, floor2(-17592186044418, 17592186044416) = -35184372088832 +floor2(35184372088832, 35184372088832) = 35184372088832, floor2(35184372088834, 35184372088832) = 35184372088832, floor2(-35184372088834, 35184372088832) = -70368744177664 +floor2(70368744177664, 70368744177664) = 70368744177664, floor2(70368744177666, 70368744177664) = 70368744177664, floor2(-70368744177666, 70368744177664) = -140737488355328 +floor2(140737488355328, 140737488355328) = 140737488355328, floor2(140737488355330, 140737488355328) = 140737488355328, floor2(-140737488355330, 140737488355328) = -281474976710656 +floor2(281474976710656, 281474976710656) = 281474976710656, floor2(281474976710658, 281474976710656) = 281474976710656, floor2(-281474976710658, 281474976710656) = -562949953421312 +floor2(562949953421312, 562949953421312) = 562949953421312, floor2(562949953421314, 562949953421312) = 562949953421312, floor2(-562949953421314, 562949953421312) = -1125899906842624 +floor2(1125899906842624, 1125899906842624) = 1125899906842624, floor2(1125899906842626, 1125899906842624) = 1125899906842624, floor2(-1125899906842626, 1125899906842624) = -2251799813685248 +floor2(2251799813685248, 2251799813685248) = 2251799813685248, floor2(2251799813685250, 2251799813685248) = 2251799813685248, floor2(-2251799813685250, 2251799813685248) = -4503599627370496 +floor2(4503599627370496, 4503599627370496) = 4503599627370496, floor2(4503599627370498, 4503599627370496) = 4503599627370496, floor2(-4503599627370498, 4503599627370496) = -9007199254740992 +floor2(9007199254740992, 9007199254740992) = 9007199254740992, floor2(9007199254740994, 9007199254740992) = 9007199254740992, floor2(-9007199254740994, 9007199254740992) = -18014398509481984 +floor2(18014398509481984, 18014398509481984) = 18014398509481984, floor2(18014398509481986, 18014398509481984) = 18014398509481984, floor2(-18014398509481986, 18014398509481984) = -36028797018963968 +floor2(36028797018963968, 36028797018963968) = 36028797018963968, floor2(36028797018963970, 36028797018963968) = 36028797018963968, floor2(-36028797018963970, 36028797018963968) = -72057594037927936 +floor2(72057594037927936, 72057594037927936) = 72057594037927936, floor2(72057594037927938, 72057594037927936) = 72057594037927936, floor2(-72057594037927938, 72057594037927936) = -144115188075855872 +floor2(144115188075855872, 144115188075855872) = 144115188075855872, floor2(144115188075855874, 144115188075855872) = 144115188075855872, floor2(-144115188075855874, 144115188075855872) = -288230376151711744 +floor2(288230376151711744, 288230376151711744) = 288230376151711744, floor2(288230376151711746, 288230376151711744) = 288230376151711744, floor2(-288230376151711746, 288230376151711744) = -576460752303423488 +floor2(576460752303423488, 576460752303423488) = 576460752303423488, floor2(576460752303423490, 576460752303423488) = 576460752303423488, floor2(-576460752303423490, 576460752303423488) = -1152921504606846976 +floor2(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor2(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor2(-1152921504606846978, 1152921504606846976) = -2305843009213693952 +floor2(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor2(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor2(-2305843009213693954, 2305843009213693952) = -4611686018427387904 +floor2(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor2(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor2(-4611686018427387906, 4611686018427387904) = -9223372036854775808 +floor2(-9223372036854775808, -9223372036854775808) = -9223372036854775808, floor2(-9223372036854775806, -9223372036854775808) = -9223372036854775808, floor2(9223372036854775806, -9223372036854775808) = 0 + +unsigned long int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(18446744073709551614, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(18446744073709551613, 1) = 18446744073709551613 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(18446744073709551612, 2) = 18446744073709551612 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(18446744073709551610, 4) = 18446744073709551608 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(18446744073709551606, 8) = 18446744073709551600 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(18446744073709551598, 16) = 18446744073709551584 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(18446744073709551582, 32) = 18446744073709551552 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(18446744073709551550, 64) = 18446744073709551488 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(18446744073709551486, 128) = 18446744073709551360 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(18446744073709551358, 256) = 18446744073709551104 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(18446744073709551102, 512) = 18446744073709550592 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(18446744073709550590, 1024) = 18446744073709549568 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(18446744073709549566, 2048) = 18446744073709547520 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(18446744073709547518, 4096) = 18446744073709543424 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(18446744073709543422, 8192) = 18446744073709535232 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(18446744073709535230, 16384) = 18446744073709518848 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(18446744073709518846, 32768) = 18446744073709486080 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(18446744073709486078, 65536) = 18446744073709420544 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(18446744073709420542, 131072) = 18446744073709289472 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(18446744073709289470, 262144) = 18446744073709027328 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(18446744073709027326, 524288) = 18446744073708503040 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(18446744073708503038, 1048576) = 18446744073707454464 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(18446744073707454462, 2097152) = 18446744073705357312 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(18446744073705357310, 4194304) = 18446744073701163008 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(18446744073701163006, 8388608) = 18446744073692774400 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(18446744073692774398, 16777216) = 18446744073675997184 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(18446744073675997182, 33554432) = 18446744073642442752 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(18446744073642442750, 67108864) = 18446744073575333888 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(18446744073575333886, 134217728) = 18446744073441116160 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(18446744073441116158, 268435456) = 18446744073172680704 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(18446744073172680702, 536870912) = 18446744072635809792 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(18446744072635809790, 1073741824) = 18446744071562067968 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(18446744071562067966, 2147483648) = 18446744069414584320 +floor2(4294967296, 4294967296) = 4294967296, floor2(4294967298, 4294967296) = 4294967296, floor2(18446744069414584318, 4294967296) = 18446744065119617024 +floor2(8589934592, 8589934592) = 8589934592, floor2(8589934594, 8589934592) = 8589934592, floor2(18446744065119617022, 8589934592) = 18446744056529682432 +floor2(17179869184, 17179869184) = 17179869184, floor2(17179869186, 17179869184) = 17179869184, floor2(18446744056529682430, 17179869184) = 18446744039349813248 +floor2(34359738368, 34359738368) = 34359738368, floor2(34359738370, 34359738368) = 34359738368, floor2(18446744039349813246, 34359738368) = 18446744004990074880 +floor2(68719476736, 68719476736) = 68719476736, floor2(68719476738, 68719476736) = 68719476736, floor2(18446744004990074878, 68719476736) = 18446743936270598144 +floor2(137438953472, 137438953472) = 137438953472, floor2(137438953474, 137438953472) = 137438953472, floor2(18446743936270598142, 137438953472) = 18446743798831644672 +floor2(274877906944, 274877906944) = 274877906944, floor2(274877906946, 274877906944) = 274877906944, floor2(18446743798831644670, 274877906944) = 18446743523953737728 +floor2(549755813888, 549755813888) = 549755813888, floor2(549755813890, 549755813888) = 549755813888, floor2(18446743523953737726, 549755813888) = 18446742974197923840 +floor2(1099511627776, 1099511627776) = 1099511627776, floor2(1099511627778, 1099511627776) = 1099511627776, floor2(18446742974197923838, 1099511627776) = 18446741874686296064 +floor2(2199023255552, 2199023255552) = 2199023255552, floor2(2199023255554, 2199023255552) = 2199023255552, floor2(18446741874686296062, 2199023255552) = 18446739675663040512 +floor2(4398046511104, 4398046511104) = 4398046511104, floor2(4398046511106, 4398046511104) = 4398046511104, floor2(18446739675663040510, 4398046511104) = 18446735277616529408 +floor2(8796093022208, 8796093022208) = 8796093022208, floor2(8796093022210, 8796093022208) = 8796093022208, floor2(18446735277616529406, 8796093022208) = 18446726481523507200 +floor2(17592186044416, 17592186044416) = 17592186044416, floor2(17592186044418, 17592186044416) = 17592186044416, floor2(18446726481523507198, 17592186044416) = 18446708889337462784 +floor2(35184372088832, 35184372088832) = 35184372088832, floor2(35184372088834, 35184372088832) = 35184372088832, floor2(18446708889337462782, 35184372088832) = 18446673704965373952 +floor2(70368744177664, 70368744177664) = 70368744177664, floor2(70368744177666, 70368744177664) = 70368744177664, floor2(18446673704965373950, 70368744177664) = 18446603336221196288 +floor2(140737488355328, 140737488355328) = 140737488355328, floor2(140737488355330, 140737488355328) = 140737488355328, floor2(18446603336221196286, 140737488355328) = 18446462598732840960 +floor2(281474976710656, 281474976710656) = 281474976710656, floor2(281474976710658, 281474976710656) = 281474976710656, floor2(18446462598732840958, 281474976710656) = 18446181123756130304 +floor2(562949953421312, 562949953421312) = 562949953421312, floor2(562949953421314, 562949953421312) = 562949953421312, floor2(18446181123756130302, 562949953421312) = 18445618173802708992 +floor2(1125899906842624, 1125899906842624) = 1125899906842624, floor2(1125899906842626, 1125899906842624) = 1125899906842624, floor2(18445618173802708990, 1125899906842624) = 18444492273895866368 +floor2(2251799813685248, 2251799813685248) = 2251799813685248, floor2(2251799813685250, 2251799813685248) = 2251799813685248, floor2(18444492273895866366, 2251799813685248) = 18442240474082181120 +floor2(4503599627370496, 4503599627370496) = 4503599627370496, floor2(4503599627370498, 4503599627370496) = 4503599627370496, floor2(18442240474082181118, 4503599627370496) = 18437736874454810624 +floor2(9007199254740992, 9007199254740992) = 9007199254740992, floor2(9007199254740994, 9007199254740992) = 9007199254740992, floor2(18437736874454810622, 9007199254740992) = 18428729675200069632 +floor2(18014398509481984, 18014398509481984) = 18014398509481984, floor2(18014398509481986, 18014398509481984) = 18014398509481984, floor2(18428729675200069630, 18014398509481984) = 18410715276690587648 +floor2(36028797018963968, 36028797018963968) = 36028797018963968, floor2(36028797018963970, 36028797018963968) = 36028797018963968, floor2(18410715276690587646, 36028797018963968) = 18374686479671623680 +floor2(72057594037927936, 72057594037927936) = 72057594037927936, floor2(72057594037927938, 72057594037927936) = 72057594037927936, floor2(18374686479671623678, 72057594037927936) = 18302628885633695744 +floor2(144115188075855872, 144115188075855872) = 144115188075855872, floor2(144115188075855874, 144115188075855872) = 144115188075855872, floor2(18302628885633695742, 144115188075855872) = 18158513697557839872 +floor2(288230376151711744, 288230376151711744) = 288230376151711744, floor2(288230376151711746, 288230376151711744) = 288230376151711744, floor2(18158513697557839870, 288230376151711744) = 17870283321406128128 +floor2(576460752303423488, 576460752303423488) = 576460752303423488, floor2(576460752303423490, 576460752303423488) = 576460752303423488, floor2(17870283321406128126, 576460752303423488) = 17293822569102704640 +floor2(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor2(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor2(17293822569102704638, 1152921504606846976) = 16140901064495857664 +floor2(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor2(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor2(16140901064495857662, 2305843009213693952) = 13835058055282163712 +floor2(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor2(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor2(13835058055282163710, 4611686018427387904) = 9223372036854775808 +floor2(9223372036854775808, 9223372036854775808) = 9223372036854775808, floor2(9223372036854775810, 9223372036854775808) = 9223372036854775808, floor2(9223372036854775806, 9223372036854775808) = 0 + +long long int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(-130, 128) = -256 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(-258, 256) = -512 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(-514, 512) = -1024 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(-1026, 1024) = -2048 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(-2050, 2048) = -4096 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(-4098, 4096) = -8192 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(-8194, 8192) = -16384 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(-16386, 16384) = -32768 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(-32770, 32768) = -65536 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(-65538, 65536) = -131072 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(-131074, 131072) = -262144 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(-262146, 262144) = -524288 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(-524290, 524288) = -1048576 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(-1048578, 1048576) = -2097152 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(-2097154, 2097152) = -4194304 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(-4194306, 4194304) = -8388608 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(-8388610, 8388608) = -16777216 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(-16777218, 16777216) = -33554432 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(-33554434, 33554432) = -67108864 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(-67108866, 67108864) = -134217728 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(-134217730, 134217728) = -268435456 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(-268435458, 268435456) = -536870912 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(-536870914, 536870912) = -1073741824 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(-1073741826, 1073741824) = -2147483648 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(-2147483650, 2147483648) = -4294967296 +floor2(4294967296, 4294967296) = 4294967296, floor2(4294967298, 4294967296) = 4294967296, floor2(-4294967298, 4294967296) = -8589934592 +floor2(8589934592, 8589934592) = 8589934592, floor2(8589934594, 8589934592) = 8589934592, floor2(-8589934594, 8589934592) = -17179869184 +floor2(17179869184, 17179869184) = 17179869184, floor2(17179869186, 17179869184) = 17179869184, floor2(-17179869186, 17179869184) = -34359738368 +floor2(34359738368, 34359738368) = 34359738368, floor2(34359738370, 34359738368) = 34359738368, floor2(-34359738370, 34359738368) = -68719476736 +floor2(68719476736, 68719476736) = 68719476736, floor2(68719476738, 68719476736) = 68719476736, floor2(-68719476738, 68719476736) = -137438953472 +floor2(137438953472, 137438953472) = 137438953472, floor2(137438953474, 137438953472) = 137438953472, floor2(-137438953474, 137438953472) = -274877906944 +floor2(274877906944, 274877906944) = 274877906944, floor2(274877906946, 274877906944) = 274877906944, floor2(-274877906946, 274877906944) = -549755813888 +floor2(549755813888, 549755813888) = 549755813888, floor2(549755813890, 549755813888) = 549755813888, floor2(-549755813890, 549755813888) = -1099511627776 +floor2(1099511627776, 1099511627776) = 1099511627776, floor2(1099511627778, 1099511627776) = 1099511627776, floor2(-1099511627778, 1099511627776) = -2199023255552 +floor2(2199023255552, 2199023255552) = 2199023255552, floor2(2199023255554, 2199023255552) = 2199023255552, floor2(-2199023255554, 2199023255552) = -4398046511104 +floor2(4398046511104, 4398046511104) = 4398046511104, floor2(4398046511106, 4398046511104) = 4398046511104, floor2(-4398046511106, 4398046511104) = -8796093022208 +floor2(8796093022208, 8796093022208) = 8796093022208, floor2(8796093022210, 8796093022208) = 8796093022208, floor2(-8796093022210, 8796093022208) = -17592186044416 +floor2(17592186044416, 17592186044416) = 17592186044416, floor2(17592186044418, 17592186044416) = 17592186044416, floor2(-17592186044418, 17592186044416) = -35184372088832 +floor2(35184372088832, 35184372088832) = 35184372088832, floor2(35184372088834, 35184372088832) = 35184372088832, floor2(-35184372088834, 35184372088832) = -70368744177664 +floor2(70368744177664, 70368744177664) = 70368744177664, floor2(70368744177666, 70368744177664) = 70368744177664, floor2(-70368744177666, 70368744177664) = -140737488355328 +floor2(140737488355328, 140737488355328) = 140737488355328, floor2(140737488355330, 140737488355328) = 140737488355328, floor2(-140737488355330, 140737488355328) = -281474976710656 +floor2(281474976710656, 281474976710656) = 281474976710656, floor2(281474976710658, 281474976710656) = 281474976710656, floor2(-281474976710658, 281474976710656) = -562949953421312 +floor2(562949953421312, 562949953421312) = 562949953421312, floor2(562949953421314, 562949953421312) = 562949953421312, floor2(-562949953421314, 562949953421312) = -1125899906842624 +floor2(1125899906842624, 1125899906842624) = 1125899906842624, floor2(1125899906842626, 1125899906842624) = 1125899906842624, floor2(-1125899906842626, 1125899906842624) = -2251799813685248 +floor2(2251799813685248, 2251799813685248) = 2251799813685248, floor2(2251799813685250, 2251799813685248) = 2251799813685248, floor2(-2251799813685250, 2251799813685248) = -4503599627370496 +floor2(4503599627370496, 4503599627370496) = 4503599627370496, floor2(4503599627370498, 4503599627370496) = 4503599627370496, floor2(-4503599627370498, 4503599627370496) = -9007199254740992 +floor2(9007199254740992, 9007199254740992) = 9007199254740992, floor2(9007199254740994, 9007199254740992) = 9007199254740992, floor2(-9007199254740994, 9007199254740992) = -18014398509481984 +floor2(18014398509481984, 18014398509481984) = 18014398509481984, floor2(18014398509481986, 18014398509481984) = 18014398509481984, floor2(-18014398509481986, 18014398509481984) = -36028797018963968 +floor2(36028797018963968, 36028797018963968) = 36028797018963968, floor2(36028797018963970, 36028797018963968) = 36028797018963968, floor2(-36028797018963970, 36028797018963968) = -72057594037927936 +floor2(72057594037927936, 72057594037927936) = 72057594037927936, floor2(72057594037927938, 72057594037927936) = 72057594037927936, floor2(-72057594037927938, 72057594037927936) = -144115188075855872 +floor2(144115188075855872, 144115188075855872) = 144115188075855872, floor2(144115188075855874, 144115188075855872) = 144115188075855872, floor2(-144115188075855874, 144115188075855872) = -288230376151711744 +floor2(288230376151711744, 288230376151711744) = 288230376151711744, floor2(288230376151711746, 288230376151711744) = 288230376151711744, floor2(-288230376151711746, 288230376151711744) = -576460752303423488 +floor2(576460752303423488, 576460752303423488) = 576460752303423488, floor2(576460752303423490, 576460752303423488) = 576460752303423488, floor2(-576460752303423490, 576460752303423488) = -1152921504606846976 +floor2(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor2(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor2(-1152921504606846978, 1152921504606846976) = -2305843009213693952 +floor2(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor2(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor2(-2305843009213693954, 2305843009213693952) = -4611686018427387904 +floor2(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor2(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor2(-4611686018427387906, 4611686018427387904) = -9223372036854775808 +floor2(-9223372036854775808, -9223372036854775808) = -9223372036854775808, floor2(-9223372036854775806, -9223372036854775808) = -9223372036854775808, floor2(9223372036854775806, -9223372036854775808) = 0 + +unsigned long long int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(18446744073709551614, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(18446744073709551613, 1) = 18446744073709551613 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(18446744073709551612, 2) = 18446744073709551612 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(18446744073709551610, 4) = 18446744073709551608 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(18446744073709551606, 8) = 18446744073709551600 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(18446744073709551598, 16) = 18446744073709551584 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(18446744073709551582, 32) = 18446744073709551552 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(18446744073709551550, 64) = 18446744073709551488 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(18446744073709551486, 128) = 18446744073709551360 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(18446744073709551358, 256) = 18446744073709551104 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(18446744073709551102, 512) = 18446744073709550592 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(18446744073709550590, 1024) = 18446744073709549568 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(18446744073709549566, 2048) = 18446744073709547520 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(18446744073709547518, 4096) = 18446744073709543424 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(18446744073709543422, 8192) = 18446744073709535232 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(18446744073709535230, 16384) = 18446744073709518848 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(18446744073709518846, 32768) = 18446744073709486080 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(18446744073709486078, 65536) = 18446744073709420544 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(18446744073709420542, 131072) = 18446744073709289472 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(18446744073709289470, 262144) = 18446744073709027328 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(18446744073709027326, 524288) = 18446744073708503040 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(18446744073708503038, 1048576) = 18446744073707454464 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(18446744073707454462, 2097152) = 18446744073705357312 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(18446744073705357310, 4194304) = 18446744073701163008 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(18446744073701163006, 8388608) = 18446744073692774400 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(18446744073692774398, 16777216) = 18446744073675997184 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(18446744073675997182, 33554432) = 18446744073642442752 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(18446744073642442750, 67108864) = 18446744073575333888 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(18446744073575333886, 134217728) = 18446744073441116160 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(18446744073441116158, 268435456) = 18446744073172680704 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(18446744073172680702, 536870912) = 18446744072635809792 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(18446744072635809790, 1073741824) = 18446744071562067968 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(18446744071562067966, 2147483648) = 18446744069414584320 +floor2(4294967296, 4294967296) = 4294967296, floor2(4294967298, 4294967296) = 4294967296, floor2(18446744069414584318, 4294967296) = 18446744065119617024 +floor2(8589934592, 8589934592) = 8589934592, floor2(8589934594, 8589934592) = 8589934592, floor2(18446744065119617022, 8589934592) = 18446744056529682432 +floor2(17179869184, 17179869184) = 17179869184, floor2(17179869186, 17179869184) = 17179869184, floor2(18446744056529682430, 17179869184) = 18446744039349813248 +floor2(34359738368, 34359738368) = 34359738368, floor2(34359738370, 34359738368) = 34359738368, floor2(18446744039349813246, 34359738368) = 18446744004990074880 +floor2(68719476736, 68719476736) = 68719476736, floor2(68719476738, 68719476736) = 68719476736, floor2(18446744004990074878, 68719476736) = 18446743936270598144 +floor2(137438953472, 137438953472) = 137438953472, floor2(137438953474, 137438953472) = 137438953472, floor2(18446743936270598142, 137438953472) = 18446743798831644672 +floor2(274877906944, 274877906944) = 274877906944, floor2(274877906946, 274877906944) = 274877906944, floor2(18446743798831644670, 274877906944) = 18446743523953737728 +floor2(549755813888, 549755813888) = 549755813888, floor2(549755813890, 549755813888) = 549755813888, floor2(18446743523953737726, 549755813888) = 18446742974197923840 +floor2(1099511627776, 1099511627776) = 1099511627776, floor2(1099511627778, 1099511627776) = 1099511627776, floor2(18446742974197923838, 1099511627776) = 18446741874686296064 +floor2(2199023255552, 2199023255552) = 2199023255552, floor2(2199023255554, 2199023255552) = 2199023255552, floor2(18446741874686296062, 2199023255552) = 18446739675663040512 +floor2(4398046511104, 4398046511104) = 4398046511104, floor2(4398046511106, 4398046511104) = 4398046511104, floor2(18446739675663040510, 4398046511104) = 18446735277616529408 +floor2(8796093022208, 8796093022208) = 8796093022208, floor2(8796093022210, 8796093022208) = 8796093022208, floor2(18446735277616529406, 8796093022208) = 18446726481523507200 +floor2(17592186044416, 17592186044416) = 17592186044416, floor2(17592186044418, 17592186044416) = 17592186044416, floor2(18446726481523507198, 17592186044416) = 18446708889337462784 +floor2(35184372088832, 35184372088832) = 35184372088832, floor2(35184372088834, 35184372088832) = 35184372088832, floor2(18446708889337462782, 35184372088832) = 18446673704965373952 +floor2(70368744177664, 70368744177664) = 70368744177664, floor2(70368744177666, 70368744177664) = 70368744177664, floor2(18446673704965373950, 70368744177664) = 18446603336221196288 +floor2(140737488355328, 140737488355328) = 140737488355328, floor2(140737488355330, 140737488355328) = 140737488355328, floor2(18446603336221196286, 140737488355328) = 18446462598732840960 +floor2(281474976710656, 281474976710656) = 281474976710656, floor2(281474976710658, 281474976710656) = 281474976710656, floor2(18446462598732840958, 281474976710656) = 18446181123756130304 +floor2(562949953421312, 562949953421312) = 562949953421312, floor2(562949953421314, 562949953421312) = 562949953421312, floor2(18446181123756130302, 562949953421312) = 18445618173802708992 +floor2(1125899906842624, 1125899906842624) = 1125899906842624, floor2(1125899906842626, 1125899906842624) = 1125899906842624, floor2(18445618173802708990, 1125899906842624) = 18444492273895866368 +floor2(2251799813685248, 2251799813685248) = 2251799813685248, floor2(2251799813685250, 2251799813685248) = 2251799813685248, floor2(18444492273895866366, 2251799813685248) = 18442240474082181120 +floor2(4503599627370496, 4503599627370496) = 4503599627370496, floor2(4503599627370498, 4503599627370496) = 4503599627370496, floor2(18442240474082181118, 4503599627370496) = 18437736874454810624 +floor2(9007199254740992, 9007199254740992) = 9007199254740992, floor2(9007199254740994, 9007199254740992) = 9007199254740992, floor2(18437736874454810622, 9007199254740992) = 18428729675200069632 +floor2(18014398509481984, 18014398509481984) = 18014398509481984, floor2(18014398509481986, 18014398509481984) = 18014398509481984, floor2(18428729675200069630, 18014398509481984) = 18410715276690587648 +floor2(36028797018963968, 36028797018963968) = 36028797018963968, floor2(36028797018963970, 36028797018963968) = 36028797018963968, floor2(18410715276690587646, 36028797018963968) = 18374686479671623680 +floor2(72057594037927936, 72057594037927936) = 72057594037927936, floor2(72057594037927938, 72057594037927936) = 72057594037927936, floor2(18374686479671623678, 72057594037927936) = 18302628885633695744 +floor2(144115188075855872, 144115188075855872) = 144115188075855872, floor2(144115188075855874, 144115188075855872) = 144115188075855872, floor2(18302628885633695742, 144115188075855872) = 18158513697557839872 +floor2(288230376151711744, 288230376151711744) = 288230376151711744, floor2(288230376151711746, 288230376151711744) = 288230376151711744, floor2(18158513697557839870, 288230376151711744) = 17870283321406128128 +floor2(576460752303423488, 576460752303423488) = 576460752303423488, floor2(576460752303423490, 576460752303423488) = 576460752303423488, floor2(17870283321406128126, 576460752303423488) = 17293822569102704640 +floor2(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor2(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor2(17293822569102704638, 1152921504606846976) = 16140901064495857664 +floor2(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor2(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor2(16140901064495857662, 2305843009213693952) = 13835058055282163712 +floor2(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor2(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor2(13835058055282163710, 4611686018427387904) = 9223372036854775808 +floor2(9223372036854775808, 9223372036854775808) = 9223372036854775808, floor2(9223372036854775810, 9223372036854775808) = 9223372036854775808, floor2(9223372036854775806, 9223372036854775808) = 0 + + +floor + +signed char +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(-128, -128) = -128, floor(-126, -128) = 0, floor(126, -128) = 0 + +unsigned char +floor(1, 1) = 1, floor(3, 1) = 3, floor(253, 1) = 253 +floor(2, 2) = 2, floor(4, 2) = 4, floor(252, 2) = 252 +floor(4, 4) = 4, floor(6, 4) = 4, floor(250, 4) = 248 +floor(8, 8) = 8, floor(10, 8) = 8, floor(246, 8) = 240 +floor(16, 16) = 16, floor(18, 16) = 16, floor(238, 16) = 224 +floor(32, 32) = 32, floor(34, 32) = 32, floor(222, 32) = 192 +floor(64, 64) = 64, floor(66, 64) = 64, floor(190, 64) = 128 +floor(128, 128) = 128, floor(130, 128) = 128, floor(126, 128) = 0 + +short int +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(128, 128) = 128, floor(130, 128) = 128, floor(-130, 128) = -128 +floor(256, 256) = 256, floor(258, 256) = 256, floor(-258, 256) = -256 +floor(512, 512) = 512, floor(514, 512) = 512, floor(-514, 512) = -512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(-1026, 1024) = -1024 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(-2050, 2048) = -2048 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(-4098, 4096) = -4096 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(-8194, 8192) = -8192 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(-16386, 16384) = -16384 +floor(-32768, -32768) = -32768, floor(-32766, -32768) = 0, floor(32766, -32768) = 0 + +unsigned short int +floor(1, 1) = 1, floor(3, 1) = 3, floor(65533, 1) = 65533 +floor(2, 2) = 2, floor(4, 2) = 4, floor(65532, 2) = 65532 +floor(4, 4) = 4, floor(6, 4) = 4, floor(65530, 4) = 65528 +floor(8, 8) = 8, floor(10, 8) = 8, floor(65526, 8) = 65520 +floor(16, 16) = 16, floor(18, 16) = 16, floor(65518, 16) = 65504 +floor(32, 32) = 32, floor(34, 32) = 32, floor(65502, 32) = 65472 +floor(64, 64) = 64, floor(66, 64) = 64, floor(65470, 64) = 65408 +floor(128, 128) = 128, floor(130, 128) = 128, floor(65406, 128) = 65280 +floor(256, 256) = 256, floor(258, 256) = 256, floor(65278, 256) = 65024 +floor(512, 512) = 512, floor(514, 512) = 512, floor(65022, 512) = 64512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(64510, 1024) = 63488 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(63486, 2048) = 61440 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(61438, 4096) = 57344 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(57342, 8192) = 49152 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(49150, 16384) = 32768 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(32766, 32768) = 0 + +int +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(128, 128) = 128, floor(130, 128) = 128, floor(-130, 128) = -128 +floor(256, 256) = 256, floor(258, 256) = 256, floor(-258, 256) = -256 +floor(512, 512) = 512, floor(514, 512) = 512, floor(-514, 512) = -512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(-1026, 1024) = -1024 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(-2050, 2048) = -2048 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(-4098, 4096) = -4096 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(-8194, 8192) = -8192 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(-16386, 16384) = -16384 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(-32770, 32768) = -32768 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(-65538, 65536) = -65536 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(-131074, 131072) = -131072 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(-262146, 262144) = -262144 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(-524290, 524288) = -524288 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(-1048578, 1048576) = -1048576 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(-2097154, 2097152) = -2097152 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(-4194306, 4194304) = -4194304 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(-8388610, 8388608) = -8388608 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(-16777218, 16777216) = -16777216 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(-33554434, 33554432) = -33554432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(-67108866, 67108864) = -67108864 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(-134217730, 134217728) = -134217728 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(-268435458, 268435456) = -268435456 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(-536870914, 536870912) = -536870912 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(-1073741826, 1073741824) = -1073741824 +floor(-2147483648, -2147483648) = -2147483648, floor(-2147483646, -2147483648) = 0, floor(2147483646, -2147483648) = 0 + +unsigned int +floor(1, 1) = 1, floor(3, 1) = 3, floor(4294967293, 1) = 4294967293 +floor(2, 2) = 2, floor(4, 2) = 4, floor(4294967292, 2) = 4294967292 +floor(4, 4) = 4, floor(6, 4) = 4, floor(4294967290, 4) = 4294967288 +floor(8, 8) = 8, floor(10, 8) = 8, floor(4294967286, 8) = 4294967280 +floor(16, 16) = 16, floor(18, 16) = 16, floor(4294967278, 16) = 4294967264 +floor(32, 32) = 32, floor(34, 32) = 32, floor(4294967262, 32) = 4294967232 +floor(64, 64) = 64, floor(66, 64) = 64, floor(4294967230, 64) = 4294967168 +floor(128, 128) = 128, floor(130, 128) = 128, floor(4294967166, 128) = 4294967040 +floor(256, 256) = 256, floor(258, 256) = 256, floor(4294967038, 256) = 4294966784 +floor(512, 512) = 512, floor(514, 512) = 512, floor(4294966782, 512) = 4294966272 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(4294966270, 1024) = 4294965248 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(4294965246, 2048) = 4294963200 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(4294963198, 4096) = 4294959104 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(4294959102, 8192) = 4294950912 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(4294950910, 16384) = 4294934528 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(4294934526, 32768) = 4294901760 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(4294901758, 65536) = 4294836224 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(4294836222, 131072) = 4294705152 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(4294705150, 262144) = 4294443008 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(4294443006, 524288) = 4293918720 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(4293918718, 1048576) = 4292870144 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(4292870142, 2097152) = 4290772992 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(4290772990, 4194304) = 4286578688 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(4286578686, 8388608) = 4278190080 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(4278190078, 16777216) = 4261412864 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(4261412862, 33554432) = 4227858432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(4227858430, 67108864) = 4160749568 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(4160749566, 134217728) = 4026531840 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(4026531838, 268435456) = 3758096384 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(3758096382, 536870912) = 3221225472 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(3221225470, 1073741824) = 2147483648 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(2147483646, 2147483648) = 0 + +long int +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(128, 128) = 128, floor(130, 128) = 128, floor(-130, 128) = -128 +floor(256, 256) = 256, floor(258, 256) = 256, floor(-258, 256) = -256 +floor(512, 512) = 512, floor(514, 512) = 512, floor(-514, 512) = -512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(-1026, 1024) = -1024 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(-2050, 2048) = -2048 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(-4098, 4096) = -4096 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(-8194, 8192) = -8192 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(-16386, 16384) = -16384 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(-32770, 32768) = -32768 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(-65538, 65536) = -65536 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(-131074, 131072) = -131072 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(-262146, 262144) = -262144 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(-524290, 524288) = -524288 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(-1048578, 1048576) = -1048576 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(-2097154, 2097152) = -2097152 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(-4194306, 4194304) = -4194304 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(-8388610, 8388608) = -8388608 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(-16777218, 16777216) = -16777216 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(-33554434, 33554432) = -33554432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(-67108866, 67108864) = -67108864 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(-134217730, 134217728) = -134217728 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(-268435458, 268435456) = -268435456 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(-536870914, 536870912) = -536870912 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(-1073741826, 1073741824) = -1073741824 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(-2147483650, 2147483648) = -2147483648 +floor(4294967296, 4294967296) = 4294967296, floor(4294967298, 4294967296) = 4294967296, floor(-4294967298, 4294967296) = -4294967296 +floor(8589934592, 8589934592) = 8589934592, floor(8589934594, 8589934592) = 8589934592, floor(-8589934594, 8589934592) = -8589934592 +floor(17179869184, 17179869184) = 17179869184, floor(17179869186, 17179869184) = 17179869184, floor(-17179869186, 17179869184) = -17179869184 +floor(34359738368, 34359738368) = 34359738368, floor(34359738370, 34359738368) = 34359738368, floor(-34359738370, 34359738368) = -34359738368 +floor(68719476736, 68719476736) = 68719476736, floor(68719476738, 68719476736) = 68719476736, floor(-68719476738, 68719476736) = -68719476736 +floor(137438953472, 137438953472) = 137438953472, floor(137438953474, 137438953472) = 137438953472, floor(-137438953474, 137438953472) = -137438953472 +floor(274877906944, 274877906944) = 274877906944, floor(274877906946, 274877906944) = 274877906944, floor(-274877906946, 274877906944) = -274877906944 +floor(549755813888, 549755813888) = 549755813888, floor(549755813890, 549755813888) = 549755813888, floor(-549755813890, 549755813888) = -549755813888 +floor(1099511627776, 1099511627776) = 1099511627776, floor(1099511627778, 1099511627776) = 1099511627776, floor(-1099511627778, 1099511627776) = -1099511627776 +floor(2199023255552, 2199023255552) = 2199023255552, floor(2199023255554, 2199023255552) = 2199023255552, floor(-2199023255554, 2199023255552) = -2199023255552 +floor(4398046511104, 4398046511104) = 4398046511104, floor(4398046511106, 4398046511104) = 4398046511104, floor(-4398046511106, 4398046511104) = -4398046511104 +floor(8796093022208, 8796093022208) = 8796093022208, floor(8796093022210, 8796093022208) = 8796093022208, floor(-8796093022210, 8796093022208) = -8796093022208 +floor(17592186044416, 17592186044416) = 17592186044416, floor(17592186044418, 17592186044416) = 17592186044416, floor(-17592186044418, 17592186044416) = -17592186044416 +floor(35184372088832, 35184372088832) = 35184372088832, floor(35184372088834, 35184372088832) = 35184372088832, floor(-35184372088834, 35184372088832) = -35184372088832 +floor(70368744177664, 70368744177664) = 70368744177664, floor(70368744177666, 70368744177664) = 70368744177664, floor(-70368744177666, 70368744177664) = -70368744177664 +floor(140737488355328, 140737488355328) = 140737488355328, floor(140737488355330, 140737488355328) = 140737488355328, floor(-140737488355330, 140737488355328) = -140737488355328 +floor(281474976710656, 281474976710656) = 281474976710656, floor(281474976710658, 281474976710656) = 281474976710656, floor(-281474976710658, 281474976710656) = -281474976710656 +floor(562949953421312, 562949953421312) = 562949953421312, floor(562949953421314, 562949953421312) = 562949953421312, floor(-562949953421314, 562949953421312) = -562949953421312 +floor(1125899906842624, 1125899906842624) = 1125899906842624, floor(1125899906842626, 1125899906842624) = 1125899906842624, floor(-1125899906842626, 1125899906842624) = -1125899906842624 +floor(2251799813685248, 2251799813685248) = 2251799813685248, floor(2251799813685250, 2251799813685248) = 2251799813685248, floor(-2251799813685250, 2251799813685248) = -2251799813685248 +floor(4503599627370496, 4503599627370496) = 4503599627370496, floor(4503599627370498, 4503599627370496) = 4503599627370496, floor(-4503599627370498, 4503599627370496) = -4503599627370496 +floor(9007199254740992, 9007199254740992) = 9007199254740992, floor(9007199254740994, 9007199254740992) = 9007199254740992, floor(-9007199254740994, 9007199254740992) = -9007199254740992 +floor(18014398509481984, 18014398509481984) = 18014398509481984, floor(18014398509481986, 18014398509481984) = 18014398509481984, floor(-18014398509481986, 18014398509481984) = -18014398509481984 +floor(36028797018963968, 36028797018963968) = 36028797018963968, floor(36028797018963970, 36028797018963968) = 36028797018963968, floor(-36028797018963970, 36028797018963968) = -36028797018963968 +floor(72057594037927936, 72057594037927936) = 72057594037927936, floor(72057594037927938, 72057594037927936) = 72057594037927936, floor(-72057594037927938, 72057594037927936) = -72057594037927936 +floor(144115188075855872, 144115188075855872) = 144115188075855872, floor(144115188075855874, 144115188075855872) = 144115188075855872, floor(-144115188075855874, 144115188075855872) = -144115188075855872 +floor(288230376151711744, 288230376151711744) = 288230376151711744, floor(288230376151711746, 288230376151711744) = 288230376151711744, floor(-288230376151711746, 288230376151711744) = -288230376151711744 +floor(576460752303423488, 576460752303423488) = 576460752303423488, floor(576460752303423490, 576460752303423488) = 576460752303423488, floor(-576460752303423490, 576460752303423488) = -576460752303423488 +floor(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor(-1152921504606846978, 1152921504606846976) = -1152921504606846976 +floor(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor(-2305843009213693954, 2305843009213693952) = -2305843009213693952 +floor(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor(-4611686018427387906, 4611686018427387904) = -4611686018427387904 +floor(-9223372036854775808, -9223372036854775808) = -9223372036854775808, floor(-9223372036854775806, -9223372036854775808) = 0, floor(9223372036854775806, -9223372036854775808) = 0 + +unsigned long int +floor(1, 1) = 1, floor(3, 1) = 3, floor(18446744073709551613, 1) = 18446744073709551613 +floor(2, 2) = 2, floor(4, 2) = 4, floor(18446744073709551612, 2) = 18446744073709551612 +floor(4, 4) = 4, floor(6, 4) = 4, floor(18446744073709551610, 4) = 18446744073709551608 +floor(8, 8) = 8, floor(10, 8) = 8, floor(18446744073709551606, 8) = 18446744073709551600 +floor(16, 16) = 16, floor(18, 16) = 16, floor(18446744073709551598, 16) = 18446744073709551584 +floor(32, 32) = 32, floor(34, 32) = 32, floor(18446744073709551582, 32) = 18446744073709551552 +floor(64, 64) = 64, floor(66, 64) = 64, floor(18446744073709551550, 64) = 18446744073709551488 +floor(128, 128) = 128, floor(130, 128) = 128, floor(18446744073709551486, 128) = 18446744073709551360 +floor(256, 256) = 256, floor(258, 256) = 256, floor(18446744073709551358, 256) = 18446744073709551104 +floor(512, 512) = 512, floor(514, 512) = 512, floor(18446744073709551102, 512) = 18446744073709550592 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(18446744073709550590, 1024) = 18446744073709549568 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(18446744073709549566, 2048) = 18446744073709547520 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(18446744073709547518, 4096) = 18446744073709543424 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(18446744073709543422, 8192) = 18446744073709535232 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(18446744073709535230, 16384) = 18446744073709518848 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(18446744073709518846, 32768) = 18446744073709486080 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(18446744073709486078, 65536) = 18446744073709420544 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(18446744073709420542, 131072) = 18446744073709289472 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(18446744073709289470, 262144) = 18446744073709027328 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(18446744073709027326, 524288) = 18446744073708503040 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(18446744073708503038, 1048576) = 18446744073707454464 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(18446744073707454462, 2097152) = 18446744073705357312 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(18446744073705357310, 4194304) = 18446744073701163008 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(18446744073701163006, 8388608) = 18446744073692774400 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(18446744073692774398, 16777216) = 18446744073675997184 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(18446744073675997182, 33554432) = 18446744073642442752 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(18446744073642442750, 67108864) = 18446744073575333888 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(18446744073575333886, 134217728) = 18446744073441116160 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(18446744073441116158, 268435456) = 18446744073172680704 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(18446744073172680702, 536870912) = 18446744072635809792 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(18446744072635809790, 1073741824) = 18446744071562067968 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(18446744071562067966, 2147483648) = 18446744069414584320 +floor(4294967296, 4294967296) = 4294967296, floor(4294967298, 4294967296) = 4294967296, floor(18446744069414584318, 4294967296) = 18446744065119617024 +floor(8589934592, 8589934592) = 8589934592, floor(8589934594, 8589934592) = 8589934592, floor(18446744065119617022, 8589934592) = 18446744056529682432 +floor(17179869184, 17179869184) = 17179869184, floor(17179869186, 17179869184) = 17179869184, floor(18446744056529682430, 17179869184) = 18446744039349813248 +floor(34359738368, 34359738368) = 34359738368, floor(34359738370, 34359738368) = 34359738368, floor(18446744039349813246, 34359738368) = 18446744004990074880 +floor(68719476736, 68719476736) = 68719476736, floor(68719476738, 68719476736) = 68719476736, floor(18446744004990074878, 68719476736) = 18446743936270598144 +floor(137438953472, 137438953472) = 137438953472, floor(137438953474, 137438953472) = 137438953472, floor(18446743936270598142, 137438953472) = 18446743798831644672 +floor(274877906944, 274877906944) = 274877906944, floor(274877906946, 274877906944) = 274877906944, floor(18446743798831644670, 274877906944) = 18446743523953737728 +floor(549755813888, 549755813888) = 549755813888, floor(549755813890, 549755813888) = 549755813888, floor(18446743523953737726, 549755813888) = 18446742974197923840 +floor(1099511627776, 1099511627776) = 1099511627776, floor(1099511627778, 1099511627776) = 1099511627776, floor(18446742974197923838, 1099511627776) = 18446741874686296064 +floor(2199023255552, 2199023255552) = 2199023255552, floor(2199023255554, 2199023255552) = 2199023255552, floor(18446741874686296062, 2199023255552) = 18446739675663040512 +floor(4398046511104, 4398046511104) = 4398046511104, floor(4398046511106, 4398046511104) = 4398046511104, floor(18446739675663040510, 4398046511104) = 18446735277616529408 +floor(8796093022208, 8796093022208) = 8796093022208, floor(8796093022210, 8796093022208) = 8796093022208, floor(18446735277616529406, 8796093022208) = 18446726481523507200 +floor(17592186044416, 17592186044416) = 17592186044416, floor(17592186044418, 17592186044416) = 17592186044416, floor(18446726481523507198, 17592186044416) = 18446708889337462784 +floor(35184372088832, 35184372088832) = 35184372088832, floor(35184372088834, 35184372088832) = 35184372088832, floor(18446708889337462782, 35184372088832) = 18446673704965373952 +floor(70368744177664, 70368744177664) = 70368744177664, floor(70368744177666, 70368744177664) = 70368744177664, floor(18446673704965373950, 70368744177664) = 18446603336221196288 +floor(140737488355328, 140737488355328) = 140737488355328, floor(140737488355330, 140737488355328) = 140737488355328, floor(18446603336221196286, 140737488355328) = 18446462598732840960 +floor(281474976710656, 281474976710656) = 281474976710656, floor(281474976710658, 281474976710656) = 281474976710656, floor(18446462598732840958, 281474976710656) = 18446181123756130304 +floor(562949953421312, 562949953421312) = 562949953421312, floor(562949953421314, 562949953421312) = 562949953421312, floor(18446181123756130302, 562949953421312) = 18445618173802708992 +floor(1125899906842624, 1125899906842624) = 1125899906842624, floor(1125899906842626, 1125899906842624) = 1125899906842624, floor(18445618173802708990, 1125899906842624) = 18444492273895866368 +floor(2251799813685248, 2251799813685248) = 2251799813685248, floor(2251799813685250, 2251799813685248) = 2251799813685248, floor(18444492273895866366, 2251799813685248) = 18442240474082181120 +floor(4503599627370496, 4503599627370496) = 4503599627370496, floor(4503599627370498, 4503599627370496) = 4503599627370496, floor(18442240474082181118, 4503599627370496) = 18437736874454810624 +floor(9007199254740992, 9007199254740992) = 9007199254740992, floor(9007199254740994, 9007199254740992) = 9007199254740992, floor(18437736874454810622, 9007199254740992) = 18428729675200069632 +floor(18014398509481984, 18014398509481984) = 18014398509481984, floor(18014398509481986, 18014398509481984) = 18014398509481984, floor(18428729675200069630, 18014398509481984) = 18410715276690587648 +floor(36028797018963968, 36028797018963968) = 36028797018963968, floor(36028797018963970, 36028797018963968) = 36028797018963968, floor(18410715276690587646, 36028797018963968) = 18374686479671623680 +floor(72057594037927936, 72057594037927936) = 72057594037927936, floor(72057594037927938, 72057594037927936) = 72057594037927936, floor(18374686479671623678, 72057594037927936) = 18302628885633695744 +floor(144115188075855872, 144115188075855872) = 144115188075855872, floor(144115188075855874, 144115188075855872) = 144115188075855872, floor(18302628885633695742, 144115188075855872) = 18158513697557839872 +floor(288230376151711744, 288230376151711744) = 288230376151711744, floor(288230376151711746, 288230376151711744) = 288230376151711744, floor(18158513697557839870, 288230376151711744) = 17870283321406128128 +floor(576460752303423488, 576460752303423488) = 576460752303423488, floor(576460752303423490, 576460752303423488) = 576460752303423488, floor(17870283321406128126, 576460752303423488) = 17293822569102704640 +floor(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor(17293822569102704638, 1152921504606846976) = 16140901064495857664 +floor(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor(16140901064495857662, 2305843009213693952) = 13835058055282163712 +floor(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor(13835058055282163710, 4611686018427387904) = 9223372036854775808 +floor(9223372036854775808, 9223372036854775808) = 9223372036854775808, floor(9223372036854775810, 9223372036854775808) = 9223372036854775808, floor(9223372036854775806, 9223372036854775808) = 0 + +long long int +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(128, 128) = 128, floor(130, 128) = 128, floor(-130, 128) = -128 +floor(256, 256) = 256, floor(258, 256) = 256, floor(-258, 256) = -256 +floor(512, 512) = 512, floor(514, 512) = 512, floor(-514, 512) = -512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(-1026, 1024) = -1024 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(-2050, 2048) = -2048 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(-4098, 4096) = -4096 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(-8194, 8192) = -8192 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(-16386, 16384) = -16384 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(-32770, 32768) = -32768 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(-65538, 65536) = -65536 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(-131074, 131072) = -131072 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(-262146, 262144) = -262144 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(-524290, 524288) = -524288 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(-1048578, 1048576) = -1048576 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(-2097154, 2097152) = -2097152 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(-4194306, 4194304) = -4194304 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(-8388610, 8388608) = -8388608 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(-16777218, 16777216) = -16777216 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(-33554434, 33554432) = -33554432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(-67108866, 67108864) = -67108864 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(-134217730, 134217728) = -134217728 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(-268435458, 268435456) = -268435456 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(-536870914, 536870912) = -536870912 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(-1073741826, 1073741824) = -1073741824 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(-2147483650, 2147483648) = -2147483648 +floor(4294967296, 4294967296) = 4294967296, floor(4294967298, 4294967296) = 4294967296, floor(-4294967298, 4294967296) = -4294967296 +floor(8589934592, 8589934592) = 8589934592, floor(8589934594, 8589934592) = 8589934592, floor(-8589934594, 8589934592) = -8589934592 +floor(17179869184, 17179869184) = 17179869184, floor(17179869186, 17179869184) = 17179869184, floor(-17179869186, 17179869184) = -17179869184 +floor(34359738368, 34359738368) = 34359738368, floor(34359738370, 34359738368) = 34359738368, floor(-34359738370, 34359738368) = -34359738368 +floor(68719476736, 68719476736) = 68719476736, floor(68719476738, 68719476736) = 68719476736, floor(-68719476738, 68719476736) = -68719476736 +floor(137438953472, 137438953472) = 137438953472, floor(137438953474, 137438953472) = 137438953472, floor(-137438953474, 137438953472) = -137438953472 +floor(274877906944, 274877906944) = 274877906944, floor(274877906946, 274877906944) = 274877906944, floor(-274877906946, 274877906944) = -274877906944 +floor(549755813888, 549755813888) = 549755813888, floor(549755813890, 549755813888) = 549755813888, floor(-549755813890, 549755813888) = -549755813888 +floor(1099511627776, 1099511627776) = 1099511627776, floor(1099511627778, 1099511627776) = 1099511627776, floor(-1099511627778, 1099511627776) = -1099511627776 +floor(2199023255552, 2199023255552) = 2199023255552, floor(2199023255554, 2199023255552) = 2199023255552, floor(-2199023255554, 2199023255552) = -2199023255552 +floor(4398046511104, 4398046511104) = 4398046511104, floor(4398046511106, 4398046511104) = 4398046511104, floor(-4398046511106, 4398046511104) = -4398046511104 +floor(8796093022208, 8796093022208) = 8796093022208, floor(8796093022210, 8796093022208) = 8796093022208, floor(-8796093022210, 8796093022208) = -8796093022208 +floor(17592186044416, 17592186044416) = 17592186044416, floor(17592186044418, 17592186044416) = 17592186044416, floor(-17592186044418, 17592186044416) = -17592186044416 +floor(35184372088832, 35184372088832) = 35184372088832, floor(35184372088834, 35184372088832) = 35184372088832, floor(-35184372088834, 35184372088832) = -35184372088832 +floor(70368744177664, 70368744177664) = 70368744177664, floor(70368744177666, 70368744177664) = 70368744177664, floor(-70368744177666, 70368744177664) = -70368744177664 +floor(140737488355328, 140737488355328) = 140737488355328, floor(140737488355330, 140737488355328) = 140737488355328, floor(-140737488355330, 140737488355328) = -140737488355328 +floor(281474976710656, 281474976710656) = 281474976710656, floor(281474976710658, 281474976710656) = 281474976710656, floor(-281474976710658, 281474976710656) = -281474976710656 +floor(562949953421312, 562949953421312) = 562949953421312, floor(562949953421314, 562949953421312) = 562949953421312, floor(-562949953421314, 562949953421312) = -562949953421312 +floor(1125899906842624, 1125899906842624) = 1125899906842624, floor(1125899906842626, 1125899906842624) = 1125899906842624, floor(-1125899906842626, 1125899906842624) = -1125899906842624 +floor(2251799813685248, 2251799813685248) = 2251799813685248, floor(2251799813685250, 2251799813685248) = 2251799813685248, floor(-2251799813685250, 2251799813685248) = -2251799813685248 +floor(4503599627370496, 4503599627370496) = 4503599627370496, floor(4503599627370498, 4503599627370496) = 4503599627370496, floor(-4503599627370498, 4503599627370496) = -4503599627370496 +floor(9007199254740992, 9007199254740992) = 9007199254740992, floor(9007199254740994, 9007199254740992) = 9007199254740992, floor(-9007199254740994, 9007199254740992) = -9007199254740992 +floor(18014398509481984, 18014398509481984) = 18014398509481984, floor(18014398509481986, 18014398509481984) = 18014398509481984, floor(-18014398509481986, 18014398509481984) = -18014398509481984 +floor(36028797018963968, 36028797018963968) = 36028797018963968, floor(36028797018963970, 36028797018963968) = 36028797018963968, floor(-36028797018963970, 36028797018963968) = -36028797018963968 +floor(72057594037927936, 72057594037927936) = 72057594037927936, floor(72057594037927938, 72057594037927936) = 72057594037927936, floor(-72057594037927938, 72057594037927936) = -72057594037927936 +floor(144115188075855872, 144115188075855872) = 144115188075855872, floor(144115188075855874, 144115188075855872) = 144115188075855872, floor(-144115188075855874, 144115188075855872) = -144115188075855872 +floor(288230376151711744, 288230376151711744) = 288230376151711744, floor(288230376151711746, 288230376151711744) = 288230376151711744, floor(-288230376151711746, 288230376151711744) = -288230376151711744 +floor(576460752303423488, 576460752303423488) = 576460752303423488, floor(576460752303423490, 576460752303423488) = 576460752303423488, floor(-576460752303423490, 576460752303423488) = -576460752303423488 +floor(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor(-1152921504606846978, 1152921504606846976) = -1152921504606846976 +floor(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor(-2305843009213693954, 2305843009213693952) = -2305843009213693952 +floor(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor(-4611686018427387906, 4611686018427387904) = -4611686018427387904 +floor(-9223372036854775808, -9223372036854775808) = -9223372036854775808, floor(-9223372036854775806, -9223372036854775808) = 0, floor(9223372036854775806, -9223372036854775808) = 0 + +unsigned long long int +floor(1, 1) = 1, floor(3, 1) = 3, floor(18446744073709551613, 1) = 18446744073709551613 +floor(2, 2) = 2, floor(4, 2) = 4, floor(18446744073709551612, 2) = 18446744073709551612 +floor(4, 4) = 4, floor(6, 4) = 4, floor(18446744073709551610, 4) = 18446744073709551608 +floor(8, 8) = 8, floor(10, 8) = 8, floor(18446744073709551606, 8) = 18446744073709551600 +floor(16, 16) = 16, floor(18, 16) = 16, floor(18446744073709551598, 16) = 18446744073709551584 +floor(32, 32) = 32, floor(34, 32) = 32, floor(18446744073709551582, 32) = 18446744073709551552 +floor(64, 64) = 64, floor(66, 64) = 64, floor(18446744073709551550, 64) = 18446744073709551488 +floor(128, 128) = 128, floor(130, 128) = 128, floor(18446744073709551486, 128) = 18446744073709551360 +floor(256, 256) = 256, floor(258, 256) = 256, floor(18446744073709551358, 256) = 18446744073709551104 +floor(512, 512) = 512, floor(514, 512) = 512, floor(18446744073709551102, 512) = 18446744073709550592 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(18446744073709550590, 1024) = 18446744073709549568 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(18446744073709549566, 2048) = 18446744073709547520 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(18446744073709547518, 4096) = 18446744073709543424 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(18446744073709543422, 8192) = 18446744073709535232 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(18446744073709535230, 16384) = 18446744073709518848 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(18446744073709518846, 32768) = 18446744073709486080 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(18446744073709486078, 65536) = 18446744073709420544 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(18446744073709420542, 131072) = 18446744073709289472 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(18446744073709289470, 262144) = 18446744073709027328 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(18446744073709027326, 524288) = 18446744073708503040 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(18446744073708503038, 1048576) = 18446744073707454464 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(18446744073707454462, 2097152) = 18446744073705357312 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(18446744073705357310, 4194304) = 18446744073701163008 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(18446744073701163006, 8388608) = 18446744073692774400 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(18446744073692774398, 16777216) = 18446744073675997184 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(18446744073675997182, 33554432) = 18446744073642442752 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(18446744073642442750, 67108864) = 18446744073575333888 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(18446744073575333886, 134217728) = 18446744073441116160 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(18446744073441116158, 268435456) = 18446744073172680704 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(18446744073172680702, 536870912) = 18446744072635809792 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(18446744072635809790, 1073741824) = 18446744071562067968 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(18446744071562067966, 2147483648) = 18446744069414584320 +floor(4294967296, 4294967296) = 4294967296, floor(4294967298, 4294967296) = 4294967296, floor(18446744069414584318, 4294967296) = 18446744065119617024 +floor(8589934592, 8589934592) = 8589934592, floor(8589934594, 8589934592) = 8589934592, floor(18446744065119617022, 8589934592) = 18446744056529682432 +floor(17179869184, 17179869184) = 17179869184, floor(17179869186, 17179869184) = 17179869184, floor(18446744056529682430, 17179869184) = 18446744039349813248 +floor(34359738368, 34359738368) = 34359738368, floor(34359738370, 34359738368) = 34359738368, floor(18446744039349813246, 34359738368) = 18446744004990074880 +floor(68719476736, 68719476736) = 68719476736, floor(68719476738, 68719476736) = 68719476736, floor(18446744004990074878, 68719476736) = 18446743936270598144 +floor(137438953472, 137438953472) = 137438953472, floor(137438953474, 137438953472) = 137438953472, floor(18446743936270598142, 137438953472) = 18446743798831644672 +floor(274877906944, 274877906944) = 274877906944, floor(274877906946, 274877906944) = 274877906944, floor(18446743798831644670, 274877906944) = 18446743523953737728 +floor(549755813888, 549755813888) = 549755813888, floor(549755813890, 549755813888) = 549755813888, floor(18446743523953737726, 549755813888) = 18446742974197923840 +floor(1099511627776, 1099511627776) = 1099511627776, floor(1099511627778, 1099511627776) = 1099511627776, floor(18446742974197923838, 1099511627776) = 18446741874686296064 +floor(2199023255552, 2199023255552) = 2199023255552, floor(2199023255554, 2199023255552) = 2199023255552, floor(18446741874686296062, 2199023255552) = 18446739675663040512 +floor(4398046511104, 4398046511104) = 4398046511104, floor(4398046511106, 4398046511104) = 4398046511104, floor(18446739675663040510, 4398046511104) = 18446735277616529408 +floor(8796093022208, 8796093022208) = 8796093022208, floor(8796093022210, 8796093022208) = 8796093022208, floor(18446735277616529406, 8796093022208) = 18446726481523507200 +floor(17592186044416, 17592186044416) = 17592186044416, floor(17592186044418, 17592186044416) = 17592186044416, floor(18446726481523507198, 17592186044416) = 18446708889337462784 +floor(35184372088832, 35184372088832) = 35184372088832, floor(35184372088834, 35184372088832) = 35184372088832, floor(18446708889337462782, 35184372088832) = 18446673704965373952 +floor(70368744177664, 70368744177664) = 70368744177664, floor(70368744177666, 70368744177664) = 70368744177664, floor(18446673704965373950, 70368744177664) = 18446603336221196288 +floor(140737488355328, 140737488355328) = 140737488355328, floor(140737488355330, 140737488355328) = 140737488355328, floor(18446603336221196286, 140737488355328) = 18446462598732840960 +floor(281474976710656, 281474976710656) = 281474976710656, floor(281474976710658, 281474976710656) = 281474976710656, floor(18446462598732840958, 281474976710656) = 18446181123756130304 +floor(562949953421312, 562949953421312) = 562949953421312, floor(562949953421314, 562949953421312) = 562949953421312, floor(18446181123756130302, 562949953421312) = 18445618173802708992 +floor(1125899906842624, 1125899906842624) = 1125899906842624, floor(1125899906842626, 1125899906842624) = 1125899906842624, floor(18445618173802708990, 1125899906842624) = 18444492273895866368 +floor(2251799813685248, 2251799813685248) = 2251799813685248, floor(2251799813685250, 2251799813685248) = 2251799813685248, floor(18444492273895866366, 2251799813685248) = 18442240474082181120 +floor(4503599627370496, 4503599627370496) = 4503599627370496, floor(4503599627370498, 4503599627370496) = 4503599627370496, floor(18442240474082181118, 4503599627370496) = 18437736874454810624 +floor(9007199254740992, 9007199254740992) = 9007199254740992, floor(9007199254740994, 9007199254740992) = 9007199254740992, floor(18437736874454810622, 9007199254740992) = 18428729675200069632 +floor(18014398509481984, 18014398509481984) = 18014398509481984, floor(18014398509481986, 18014398509481984) = 18014398509481984, floor(18428729675200069630, 18014398509481984) = 18410715276690587648 +floor(36028797018963968, 36028797018963968) = 36028797018963968, floor(36028797018963970, 36028797018963968) = 36028797018963968, floor(18410715276690587646, 36028797018963968) = 18374686479671623680 +floor(72057594037927936, 72057594037927936) = 72057594037927936, floor(72057594037927938, 72057594037927936) = 72057594037927936, floor(18374686479671623678, 72057594037927936) = 18302628885633695744 +floor(144115188075855872, 144115188075855872) = 144115188075855872, floor(144115188075855874, 144115188075855872) = 144115188075855872, floor(18302628885633695742, 144115188075855872) = 18158513697557839872 +floor(288230376151711744, 288230376151711744) = 288230376151711744, floor(288230376151711746, 288230376151711744) = 288230376151711744, floor(18158513697557839870, 288230376151711744) = 17870283321406128128 +floor(576460752303423488, 576460752303423488) = 576460752303423488, floor(576460752303423490, 576460752303423488) = 576460752303423488, floor(17870283321406128126, 576460752303423488) = 17293822569102704640 +floor(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor(17293822569102704638, 1152921504606846976) = 16140901064495857664 +floor(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor(16140901064495857662, 2305843009213693952) = 13835058055282163712 +floor(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor(13835058055282163710, 4611686018427387904) = 9223372036854775808 +floor(9223372036854775808, 9223372036854775808) = 9223372036854775808, floor(9223372036854775810, 9223372036854775808) = 9223372036854775808, floor(9223372036854775806, 9223372036854775808) = 0 + + +ceiling2 + +signed char +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = -128, ceiling2(-66, 64) = -64 +ceiling2(-128, -128) = -128, ceiling2(-126, -128) = 0, ceiling2(126, -128) = -128 + +unsigned char +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(254, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(253, 1) = 253 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(252, 2) = 252 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(250, 4) = 252 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(246, 8) = 248 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(238, 16) = 240 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(222, 32) = 224 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(190, 64) = 192 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 0, ceiling2(126, 128) = 128 + +short int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(-66, 64) = -64 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(-130, 128) = -128 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(-258, 256) = -256 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(-514, 512) = -512 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(-1026, 1024) = -1024 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(-2050, 2048) = -2048 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(-4098, 4096) = -4096 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(-8194, 8192) = -8192 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = -32768, ceiling2(-16386, 16384) = -16384 +ceiling2(-32768, -32768) = -32768, ceiling2(-32766, -32768) = 0, ceiling2(32766, -32768) = -32768 + +unsigned short int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(65534, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(65533, 1) = 65533 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(65532, 2) = 65532 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(65530, 4) = 65532 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(65526, 8) = 65528 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(65518, 16) = 65520 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(65502, 32) = 65504 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(65470, 64) = 65472 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(65406, 128) = 65408 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(65278, 256) = 65280 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(65022, 512) = 65024 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(64510, 1024) = 64512 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(63486, 2048) = 63488 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(61438, 4096) = 61440 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(57342, 8192) = 57344 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(49150, 16384) = 49152 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 0, ceiling2(32766, 32768) = 32768 + +int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(-66, 64) = -64 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(-130, 128) = -128 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(-258, 256) = -256 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(-514, 512) = -512 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(-1026, 1024) = -1024 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(-2050, 2048) = -2048 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(-4098, 4096) = -4096 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(-8194, 8192) = -8192 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(-16386, 16384) = -16384 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(-32770, 32768) = -32768 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(-65538, 65536) = -65536 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(-131074, 131072) = -131072 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(-262146, 262144) = -262144 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(-524290, 524288) = -524288 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(-1048578, 1048576) = -1048576 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(-2097154, 2097152) = -2097152 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(-4194306, 4194304) = -4194304 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(-8388610, 8388608) = -8388608 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(-16777218, 16777216) = -16777216 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(-33554434, 33554432) = -33554432 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(-67108866, 67108864) = -67108864 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(-134217730, 134217728) = -134217728 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(-268435458, 268435456) = -268435456 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(-536870914, 536870912) = -536870912 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = -2147483648, ceiling2(-1073741826, 1073741824) = -1073741824 +ceiling2(-2147483648, -2147483648) = -2147483648, ceiling2(-2147483646, -2147483648) = 0, ceiling2(2147483646, -2147483648) = -2147483648 + +unsigned int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(4294967294, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(4294967293, 1) = 4294967293 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(4294967292, 2) = 4294967292 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(4294967290, 4) = 4294967292 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(4294967286, 8) = 4294967288 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(4294967278, 16) = 4294967280 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(4294967262, 32) = 4294967264 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(4294967230, 64) = 4294967232 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(4294967166, 128) = 4294967168 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(4294967038, 256) = 4294967040 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(4294966782, 512) = 4294966784 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(4294966270, 1024) = 4294966272 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(4294965246, 2048) = 4294965248 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(4294963198, 4096) = 4294963200 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(4294959102, 8192) = 4294959104 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(4294950910, 16384) = 4294950912 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(4294934526, 32768) = 4294934528 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(4294901758, 65536) = 4294901760 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(4294836222, 131072) = 4294836224 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(4294705150, 262144) = 4294705152 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(4294443006, 524288) = 4294443008 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(4293918718, 1048576) = 4293918720 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(4292870142, 2097152) = 4292870144 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(4290772990, 4194304) = 4290772992 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(4286578686, 8388608) = 4286578688 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(4278190078, 16777216) = 4278190080 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(4261412862, 33554432) = 4261412864 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(4227858430, 67108864) = 4227858432 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(4160749566, 134217728) = 4160749568 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(4026531838, 268435456) = 4026531840 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(3758096382, 536870912) = 3758096384 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(3221225470, 1073741824) = 3221225472 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 0, ceiling2(2147483646, 2147483648) = 2147483648 + +long int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(-66, 64) = -64 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(-130, 128) = -128 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(-258, 256) = -256 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(-514, 512) = -512 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(-1026, 1024) = -1024 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(-2050, 2048) = -2048 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(-4098, 4096) = -4096 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(-8194, 8192) = -8192 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(-16386, 16384) = -16384 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(-32770, 32768) = -32768 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(-65538, 65536) = -65536 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(-131074, 131072) = -131072 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(-262146, 262144) = -262144 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(-524290, 524288) = -524288 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(-1048578, 1048576) = -1048576 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(-2097154, 2097152) = -2097152 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(-4194306, 4194304) = -4194304 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(-8388610, 8388608) = -8388608 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(-16777218, 16777216) = -16777216 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(-33554434, 33554432) = -33554432 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(-67108866, 67108864) = -67108864 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(-134217730, 134217728) = -134217728 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(-268435458, 268435456) = -268435456 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(-536870914, 536870912) = -536870912 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(-1073741826, 1073741824) = -1073741824 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 4294967296, ceiling2(-2147483650, 2147483648) = -2147483648 +ceiling2(4294967296, 4294967296) = 4294967296, ceiling2(4294967298, 4294967296) = 8589934592, ceiling2(-4294967298, 4294967296) = -4294967296 +ceiling2(8589934592, 8589934592) = 8589934592, ceiling2(8589934594, 8589934592) = 17179869184, ceiling2(-8589934594, 8589934592) = -8589934592 +ceiling2(17179869184, 17179869184) = 17179869184, ceiling2(17179869186, 17179869184) = 34359738368, ceiling2(-17179869186, 17179869184) = -17179869184 +ceiling2(34359738368, 34359738368) = 34359738368, ceiling2(34359738370, 34359738368) = 68719476736, ceiling2(-34359738370, 34359738368) = -34359738368 +ceiling2(68719476736, 68719476736) = 68719476736, ceiling2(68719476738, 68719476736) = 137438953472, ceiling2(-68719476738, 68719476736) = -68719476736 +ceiling2(137438953472, 137438953472) = 137438953472, ceiling2(137438953474, 137438953472) = 274877906944, ceiling2(-137438953474, 137438953472) = -137438953472 +ceiling2(274877906944, 274877906944) = 274877906944, ceiling2(274877906946, 274877906944) = 549755813888, ceiling2(-274877906946, 274877906944) = -274877906944 +ceiling2(549755813888, 549755813888) = 549755813888, ceiling2(549755813890, 549755813888) = 1099511627776, ceiling2(-549755813890, 549755813888) = -549755813888 +ceiling2(1099511627776, 1099511627776) = 1099511627776, ceiling2(1099511627778, 1099511627776) = 2199023255552, ceiling2(-1099511627778, 1099511627776) = -1099511627776 +ceiling2(2199023255552, 2199023255552) = 2199023255552, ceiling2(2199023255554, 2199023255552) = 4398046511104, ceiling2(-2199023255554, 2199023255552) = -2199023255552 +ceiling2(4398046511104, 4398046511104) = 4398046511104, ceiling2(4398046511106, 4398046511104) = 8796093022208, ceiling2(-4398046511106, 4398046511104) = -4398046511104 +ceiling2(8796093022208, 8796093022208) = 8796093022208, ceiling2(8796093022210, 8796093022208) = 17592186044416, ceiling2(-8796093022210, 8796093022208) = -8796093022208 +ceiling2(17592186044416, 17592186044416) = 17592186044416, ceiling2(17592186044418, 17592186044416) = 35184372088832, ceiling2(-17592186044418, 17592186044416) = -17592186044416 +ceiling2(35184372088832, 35184372088832) = 35184372088832, ceiling2(35184372088834, 35184372088832) = 70368744177664, ceiling2(-35184372088834, 35184372088832) = -35184372088832 +ceiling2(70368744177664, 70368744177664) = 70368744177664, ceiling2(70368744177666, 70368744177664) = 140737488355328, ceiling2(-70368744177666, 70368744177664) = -70368744177664 +ceiling2(140737488355328, 140737488355328) = 140737488355328, ceiling2(140737488355330, 140737488355328) = 281474976710656, ceiling2(-140737488355330, 140737488355328) = -140737488355328 +ceiling2(281474976710656, 281474976710656) = 281474976710656, ceiling2(281474976710658, 281474976710656) = 562949953421312, ceiling2(-281474976710658, 281474976710656) = -281474976710656 +ceiling2(562949953421312, 562949953421312) = 562949953421312, ceiling2(562949953421314, 562949953421312) = 1125899906842624, ceiling2(-562949953421314, 562949953421312) = -562949953421312 +ceiling2(1125899906842624, 1125899906842624) = 1125899906842624, ceiling2(1125899906842626, 1125899906842624) = 2251799813685248, ceiling2(-1125899906842626, 1125899906842624) = -1125899906842624 +ceiling2(2251799813685248, 2251799813685248) = 2251799813685248, ceiling2(2251799813685250, 2251799813685248) = 4503599627370496, ceiling2(-2251799813685250, 2251799813685248) = -2251799813685248 +ceiling2(4503599627370496, 4503599627370496) = 4503599627370496, ceiling2(4503599627370498, 4503599627370496) = 9007199254740992, ceiling2(-4503599627370498, 4503599627370496) = -4503599627370496 +ceiling2(9007199254740992, 9007199254740992) = 9007199254740992, ceiling2(9007199254740994, 9007199254740992) = 18014398509481984, ceiling2(-9007199254740994, 9007199254740992) = -9007199254740992 +ceiling2(18014398509481984, 18014398509481984) = 18014398509481984, ceiling2(18014398509481986, 18014398509481984) = 36028797018963968, ceiling2(-18014398509481986, 18014398509481984) = -18014398509481984 +ceiling2(36028797018963968, 36028797018963968) = 36028797018963968, ceiling2(36028797018963970, 36028797018963968) = 72057594037927936, ceiling2(-36028797018963970, 36028797018963968) = -36028797018963968 +ceiling2(72057594037927936, 72057594037927936) = 72057594037927936, ceiling2(72057594037927938, 72057594037927936) = 144115188075855872, ceiling2(-72057594037927938, 72057594037927936) = -72057594037927936 +ceiling2(144115188075855872, 144115188075855872) = 144115188075855872, ceiling2(144115188075855874, 144115188075855872) = 288230376151711744, ceiling2(-144115188075855874, 144115188075855872) = -144115188075855872 +ceiling2(288230376151711744, 288230376151711744) = 288230376151711744, ceiling2(288230376151711746, 288230376151711744) = 576460752303423488, ceiling2(-288230376151711746, 288230376151711744) = -288230376151711744 +ceiling2(576460752303423488, 576460752303423488) = 576460752303423488, ceiling2(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling2(-576460752303423490, 576460752303423488) = -576460752303423488 +ceiling2(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling2(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling2(-1152921504606846978, 1152921504606846976) = -1152921504606846976 +ceiling2(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling2(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling2(-2305843009213693954, 2305843009213693952) = -2305843009213693952 +ceiling2(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling2(4611686018427387906, 4611686018427387904) = -9223372036854775808, ceiling2(-4611686018427387906, 4611686018427387904) = -4611686018427387904 +ceiling2(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling2(-9223372036854775806, -9223372036854775808) = 0, ceiling2(9223372036854775806, -9223372036854775808) = -9223372036854775808 + +unsigned long int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(18446744073709551614, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(18446744073709551613, 1) = 18446744073709551613 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(18446744073709551612, 2) = 18446744073709551612 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(18446744073709551610, 4) = 18446744073709551612 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(18446744073709551606, 8) = 18446744073709551608 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(18446744073709551598, 16) = 18446744073709551600 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(18446744073709551582, 32) = 18446744073709551584 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(18446744073709551550, 64) = 18446744073709551552 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(18446744073709551486, 128) = 18446744073709551488 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(18446744073709551358, 256) = 18446744073709551360 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(18446744073709551102, 512) = 18446744073709551104 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(18446744073709550590, 1024) = 18446744073709550592 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(18446744073709549566, 2048) = 18446744073709549568 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(18446744073709547518, 4096) = 18446744073709547520 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(18446744073709543422, 8192) = 18446744073709543424 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(18446744073709535230, 16384) = 18446744073709535232 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(18446744073709518846, 32768) = 18446744073709518848 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(18446744073709486078, 65536) = 18446744073709486080 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(18446744073709420542, 131072) = 18446744073709420544 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(18446744073709289470, 262144) = 18446744073709289472 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(18446744073709027326, 524288) = 18446744073709027328 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(18446744073708503038, 1048576) = 18446744073708503040 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(18446744073707454462, 2097152) = 18446744073707454464 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(18446744073705357310, 4194304) = 18446744073705357312 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(18446744073701163006, 8388608) = 18446744073701163008 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(18446744073692774398, 16777216) = 18446744073692774400 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(18446744073675997182, 33554432) = 18446744073675997184 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(18446744073642442750, 67108864) = 18446744073642442752 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(18446744073575333886, 134217728) = 18446744073575333888 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(18446744073441116158, 268435456) = 18446744073441116160 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(18446744073172680702, 536870912) = 18446744073172680704 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(18446744072635809790, 1073741824) = 18446744072635809792 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 4294967296, ceiling2(18446744071562067966, 2147483648) = 18446744071562067968 +ceiling2(4294967296, 4294967296) = 4294967296, ceiling2(4294967298, 4294967296) = 8589934592, ceiling2(18446744069414584318, 4294967296) = 18446744069414584320 +ceiling2(8589934592, 8589934592) = 8589934592, ceiling2(8589934594, 8589934592) = 17179869184, ceiling2(18446744065119617022, 8589934592) = 18446744065119617024 +ceiling2(17179869184, 17179869184) = 17179869184, ceiling2(17179869186, 17179869184) = 34359738368, ceiling2(18446744056529682430, 17179869184) = 18446744056529682432 +ceiling2(34359738368, 34359738368) = 34359738368, ceiling2(34359738370, 34359738368) = 68719476736, ceiling2(18446744039349813246, 34359738368) = 18446744039349813248 +ceiling2(68719476736, 68719476736) = 68719476736, ceiling2(68719476738, 68719476736) = 137438953472, ceiling2(18446744004990074878, 68719476736) = 18446744004990074880 +ceiling2(137438953472, 137438953472) = 137438953472, ceiling2(137438953474, 137438953472) = 274877906944, ceiling2(18446743936270598142, 137438953472) = 18446743936270598144 +ceiling2(274877906944, 274877906944) = 274877906944, ceiling2(274877906946, 274877906944) = 549755813888, ceiling2(18446743798831644670, 274877906944) = 18446743798831644672 +ceiling2(549755813888, 549755813888) = 549755813888, ceiling2(549755813890, 549755813888) = 1099511627776, ceiling2(18446743523953737726, 549755813888) = 18446743523953737728 +ceiling2(1099511627776, 1099511627776) = 1099511627776, ceiling2(1099511627778, 1099511627776) = 2199023255552, ceiling2(18446742974197923838, 1099511627776) = 18446742974197923840 +ceiling2(2199023255552, 2199023255552) = 2199023255552, ceiling2(2199023255554, 2199023255552) = 4398046511104, ceiling2(18446741874686296062, 2199023255552) = 18446741874686296064 +ceiling2(4398046511104, 4398046511104) = 4398046511104, ceiling2(4398046511106, 4398046511104) = 8796093022208, ceiling2(18446739675663040510, 4398046511104) = 18446739675663040512 +ceiling2(8796093022208, 8796093022208) = 8796093022208, ceiling2(8796093022210, 8796093022208) = 17592186044416, ceiling2(18446735277616529406, 8796093022208) = 18446735277616529408 +ceiling2(17592186044416, 17592186044416) = 17592186044416, ceiling2(17592186044418, 17592186044416) = 35184372088832, ceiling2(18446726481523507198, 17592186044416) = 18446726481523507200 +ceiling2(35184372088832, 35184372088832) = 35184372088832, ceiling2(35184372088834, 35184372088832) = 70368744177664, ceiling2(18446708889337462782, 35184372088832) = 18446708889337462784 +ceiling2(70368744177664, 70368744177664) = 70368744177664, ceiling2(70368744177666, 70368744177664) = 140737488355328, ceiling2(18446673704965373950, 70368744177664) = 18446673704965373952 +ceiling2(140737488355328, 140737488355328) = 140737488355328, ceiling2(140737488355330, 140737488355328) = 281474976710656, ceiling2(18446603336221196286, 140737488355328) = 18446603336221196288 +ceiling2(281474976710656, 281474976710656) = 281474976710656, ceiling2(281474976710658, 281474976710656) = 562949953421312, ceiling2(18446462598732840958, 281474976710656) = 18446462598732840960 +ceiling2(562949953421312, 562949953421312) = 562949953421312, ceiling2(562949953421314, 562949953421312) = 1125899906842624, ceiling2(18446181123756130302, 562949953421312) = 18446181123756130304 +ceiling2(1125899906842624, 1125899906842624) = 1125899906842624, ceiling2(1125899906842626, 1125899906842624) = 2251799813685248, ceiling2(18445618173802708990, 1125899906842624) = 18445618173802708992 +ceiling2(2251799813685248, 2251799813685248) = 2251799813685248, ceiling2(2251799813685250, 2251799813685248) = 4503599627370496, ceiling2(18444492273895866366, 2251799813685248) = 18444492273895866368 +ceiling2(4503599627370496, 4503599627370496) = 4503599627370496, ceiling2(4503599627370498, 4503599627370496) = 9007199254740992, ceiling2(18442240474082181118, 4503599627370496) = 18442240474082181120 +ceiling2(9007199254740992, 9007199254740992) = 9007199254740992, ceiling2(9007199254740994, 9007199254740992) = 18014398509481984, ceiling2(18437736874454810622, 9007199254740992) = 18437736874454810624 +ceiling2(18014398509481984, 18014398509481984) = 18014398509481984, ceiling2(18014398509481986, 18014398509481984) = 36028797018963968, ceiling2(18428729675200069630, 18014398509481984) = 18428729675200069632 +ceiling2(36028797018963968, 36028797018963968) = 36028797018963968, ceiling2(36028797018963970, 36028797018963968) = 72057594037927936, ceiling2(18410715276690587646, 36028797018963968) = 18410715276690587648 +ceiling2(72057594037927936, 72057594037927936) = 72057594037927936, ceiling2(72057594037927938, 72057594037927936) = 144115188075855872, ceiling2(18374686479671623678, 72057594037927936) = 18374686479671623680 +ceiling2(144115188075855872, 144115188075855872) = 144115188075855872, ceiling2(144115188075855874, 144115188075855872) = 288230376151711744, ceiling2(18302628885633695742, 144115188075855872) = 18302628885633695744 +ceiling2(288230376151711744, 288230376151711744) = 288230376151711744, ceiling2(288230376151711746, 288230376151711744) = 576460752303423488, ceiling2(18158513697557839870, 288230376151711744) = 18158513697557839872 +ceiling2(576460752303423488, 576460752303423488) = 576460752303423488, ceiling2(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling2(17870283321406128126, 576460752303423488) = 17870283321406128128 +ceiling2(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling2(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling2(17293822569102704638, 1152921504606846976) = 17293822569102704640 +ceiling2(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling2(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling2(16140901064495857662, 2305843009213693952) = 16140901064495857664 +ceiling2(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling2(4611686018427387906, 4611686018427387904) = 9223372036854775808, ceiling2(13835058055282163710, 4611686018427387904) = 13835058055282163712 +ceiling2(9223372036854775808, 9223372036854775808) = 9223372036854775808, ceiling2(9223372036854775810, 9223372036854775808) = 0, ceiling2(9223372036854775806, 9223372036854775808) = 9223372036854775808 + +long long int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(-66, 64) = -64 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(-130, 128) = -128 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(-258, 256) = -256 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(-514, 512) = -512 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(-1026, 1024) = -1024 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(-2050, 2048) = -2048 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(-4098, 4096) = -4096 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(-8194, 8192) = -8192 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(-16386, 16384) = -16384 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(-32770, 32768) = -32768 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(-65538, 65536) = -65536 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(-131074, 131072) = -131072 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(-262146, 262144) = -262144 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(-524290, 524288) = -524288 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(-1048578, 1048576) = -1048576 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(-2097154, 2097152) = -2097152 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(-4194306, 4194304) = -4194304 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(-8388610, 8388608) = -8388608 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(-16777218, 16777216) = -16777216 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(-33554434, 33554432) = -33554432 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(-67108866, 67108864) = -67108864 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(-134217730, 134217728) = -134217728 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(-268435458, 268435456) = -268435456 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(-536870914, 536870912) = -536870912 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(-1073741826, 1073741824) = -1073741824 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 4294967296, ceiling2(-2147483650, 2147483648) = -2147483648 +ceiling2(4294967296, 4294967296) = 4294967296, ceiling2(4294967298, 4294967296) = 8589934592, ceiling2(-4294967298, 4294967296) = -4294967296 +ceiling2(8589934592, 8589934592) = 8589934592, ceiling2(8589934594, 8589934592) = 17179869184, ceiling2(-8589934594, 8589934592) = -8589934592 +ceiling2(17179869184, 17179869184) = 17179869184, ceiling2(17179869186, 17179869184) = 34359738368, ceiling2(-17179869186, 17179869184) = -17179869184 +ceiling2(34359738368, 34359738368) = 34359738368, ceiling2(34359738370, 34359738368) = 68719476736, ceiling2(-34359738370, 34359738368) = -34359738368 +ceiling2(68719476736, 68719476736) = 68719476736, ceiling2(68719476738, 68719476736) = 137438953472, ceiling2(-68719476738, 68719476736) = -68719476736 +ceiling2(137438953472, 137438953472) = 137438953472, ceiling2(137438953474, 137438953472) = 274877906944, ceiling2(-137438953474, 137438953472) = -137438953472 +ceiling2(274877906944, 274877906944) = 274877906944, ceiling2(274877906946, 274877906944) = 549755813888, ceiling2(-274877906946, 274877906944) = -274877906944 +ceiling2(549755813888, 549755813888) = 549755813888, ceiling2(549755813890, 549755813888) = 1099511627776, ceiling2(-549755813890, 549755813888) = -549755813888 +ceiling2(1099511627776, 1099511627776) = 1099511627776, ceiling2(1099511627778, 1099511627776) = 2199023255552, ceiling2(-1099511627778, 1099511627776) = -1099511627776 +ceiling2(2199023255552, 2199023255552) = 2199023255552, ceiling2(2199023255554, 2199023255552) = 4398046511104, ceiling2(-2199023255554, 2199023255552) = -2199023255552 +ceiling2(4398046511104, 4398046511104) = 4398046511104, ceiling2(4398046511106, 4398046511104) = 8796093022208, ceiling2(-4398046511106, 4398046511104) = -4398046511104 +ceiling2(8796093022208, 8796093022208) = 8796093022208, ceiling2(8796093022210, 8796093022208) = 17592186044416, ceiling2(-8796093022210, 8796093022208) = -8796093022208 +ceiling2(17592186044416, 17592186044416) = 17592186044416, ceiling2(17592186044418, 17592186044416) = 35184372088832, ceiling2(-17592186044418, 17592186044416) = -17592186044416 +ceiling2(35184372088832, 35184372088832) = 35184372088832, ceiling2(35184372088834, 35184372088832) = 70368744177664, ceiling2(-35184372088834, 35184372088832) = -35184372088832 +ceiling2(70368744177664, 70368744177664) = 70368744177664, ceiling2(70368744177666, 70368744177664) = 140737488355328, ceiling2(-70368744177666, 70368744177664) = -70368744177664 +ceiling2(140737488355328, 140737488355328) = 140737488355328, ceiling2(140737488355330, 140737488355328) = 281474976710656, ceiling2(-140737488355330, 140737488355328) = -140737488355328 +ceiling2(281474976710656, 281474976710656) = 281474976710656, ceiling2(281474976710658, 281474976710656) = 562949953421312, ceiling2(-281474976710658, 281474976710656) = -281474976710656 +ceiling2(562949953421312, 562949953421312) = 562949953421312, ceiling2(562949953421314, 562949953421312) = 1125899906842624, ceiling2(-562949953421314, 562949953421312) = -562949953421312 +ceiling2(1125899906842624, 1125899906842624) = 1125899906842624, ceiling2(1125899906842626, 1125899906842624) = 2251799813685248, ceiling2(-1125899906842626, 1125899906842624) = -1125899906842624 +ceiling2(2251799813685248, 2251799813685248) = 2251799813685248, ceiling2(2251799813685250, 2251799813685248) = 4503599627370496, ceiling2(-2251799813685250, 2251799813685248) = -2251799813685248 +ceiling2(4503599627370496, 4503599627370496) = 4503599627370496, ceiling2(4503599627370498, 4503599627370496) = 9007199254740992, ceiling2(-4503599627370498, 4503599627370496) = -4503599627370496 +ceiling2(9007199254740992, 9007199254740992) = 9007199254740992, ceiling2(9007199254740994, 9007199254740992) = 18014398509481984, ceiling2(-9007199254740994, 9007199254740992) = -9007199254740992 +ceiling2(18014398509481984, 18014398509481984) = 18014398509481984, ceiling2(18014398509481986, 18014398509481984) = 36028797018963968, ceiling2(-18014398509481986, 18014398509481984) = -18014398509481984 +ceiling2(36028797018963968, 36028797018963968) = 36028797018963968, ceiling2(36028797018963970, 36028797018963968) = 72057594037927936, ceiling2(-36028797018963970, 36028797018963968) = -36028797018963968 +ceiling2(72057594037927936, 72057594037927936) = 72057594037927936, ceiling2(72057594037927938, 72057594037927936) = 144115188075855872, ceiling2(-72057594037927938, 72057594037927936) = -72057594037927936 +ceiling2(144115188075855872, 144115188075855872) = 144115188075855872, ceiling2(144115188075855874, 144115188075855872) = 288230376151711744, ceiling2(-144115188075855874, 144115188075855872) = -144115188075855872 +ceiling2(288230376151711744, 288230376151711744) = 288230376151711744, ceiling2(288230376151711746, 288230376151711744) = 576460752303423488, ceiling2(-288230376151711746, 288230376151711744) = -288230376151711744 +ceiling2(576460752303423488, 576460752303423488) = 576460752303423488, ceiling2(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling2(-576460752303423490, 576460752303423488) = -576460752303423488 +ceiling2(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling2(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling2(-1152921504606846978, 1152921504606846976) = -1152921504606846976 +ceiling2(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling2(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling2(-2305843009213693954, 2305843009213693952) = -2305843009213693952 +ceiling2(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling2(4611686018427387906, 4611686018427387904) = -9223372036854775808, ceiling2(-4611686018427387906, 4611686018427387904) = -4611686018427387904 +ceiling2(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling2(-9223372036854775806, -9223372036854775808) = 0, ceiling2(9223372036854775806, -9223372036854775808) = -9223372036854775808 + +unsigned long long int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(18446744073709551614, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(18446744073709551613, 1) = 18446744073709551613 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(18446744073709551612, 2) = 18446744073709551612 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(18446744073709551610, 4) = 18446744073709551612 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(18446744073709551606, 8) = 18446744073709551608 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(18446744073709551598, 16) = 18446744073709551600 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(18446744073709551582, 32) = 18446744073709551584 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(18446744073709551550, 64) = 18446744073709551552 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(18446744073709551486, 128) = 18446744073709551488 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(18446744073709551358, 256) = 18446744073709551360 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(18446744073709551102, 512) = 18446744073709551104 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(18446744073709550590, 1024) = 18446744073709550592 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(18446744073709549566, 2048) = 18446744073709549568 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(18446744073709547518, 4096) = 18446744073709547520 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(18446744073709543422, 8192) = 18446744073709543424 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(18446744073709535230, 16384) = 18446744073709535232 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(18446744073709518846, 32768) = 18446744073709518848 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(18446744073709486078, 65536) = 18446744073709486080 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(18446744073709420542, 131072) = 18446744073709420544 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(18446744073709289470, 262144) = 18446744073709289472 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(18446744073709027326, 524288) = 18446744073709027328 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(18446744073708503038, 1048576) = 18446744073708503040 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(18446744073707454462, 2097152) = 18446744073707454464 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(18446744073705357310, 4194304) = 18446744073705357312 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(18446744073701163006, 8388608) = 18446744073701163008 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(18446744073692774398, 16777216) = 18446744073692774400 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(18446744073675997182, 33554432) = 18446744073675997184 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(18446744073642442750, 67108864) = 18446744073642442752 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(18446744073575333886, 134217728) = 18446744073575333888 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(18446744073441116158, 268435456) = 18446744073441116160 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(18446744073172680702, 536870912) = 18446744073172680704 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(18446744072635809790, 1073741824) = 18446744072635809792 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 4294967296, ceiling2(18446744071562067966, 2147483648) = 18446744071562067968 +ceiling2(4294967296, 4294967296) = 4294967296, ceiling2(4294967298, 4294967296) = 8589934592, ceiling2(18446744069414584318, 4294967296) = 18446744069414584320 +ceiling2(8589934592, 8589934592) = 8589934592, ceiling2(8589934594, 8589934592) = 17179869184, ceiling2(18446744065119617022, 8589934592) = 18446744065119617024 +ceiling2(17179869184, 17179869184) = 17179869184, ceiling2(17179869186, 17179869184) = 34359738368, ceiling2(18446744056529682430, 17179869184) = 18446744056529682432 +ceiling2(34359738368, 34359738368) = 34359738368, ceiling2(34359738370, 34359738368) = 68719476736, ceiling2(18446744039349813246, 34359738368) = 18446744039349813248 +ceiling2(68719476736, 68719476736) = 68719476736, ceiling2(68719476738, 68719476736) = 137438953472, ceiling2(18446744004990074878, 68719476736) = 18446744004990074880 +ceiling2(137438953472, 137438953472) = 137438953472, ceiling2(137438953474, 137438953472) = 274877906944, ceiling2(18446743936270598142, 137438953472) = 18446743936270598144 +ceiling2(274877906944, 274877906944) = 274877906944, ceiling2(274877906946, 274877906944) = 549755813888, ceiling2(18446743798831644670, 274877906944) = 18446743798831644672 +ceiling2(549755813888, 549755813888) = 549755813888, ceiling2(549755813890, 549755813888) = 1099511627776, ceiling2(18446743523953737726, 549755813888) = 18446743523953737728 +ceiling2(1099511627776, 1099511627776) = 1099511627776, ceiling2(1099511627778, 1099511627776) = 2199023255552, ceiling2(18446742974197923838, 1099511627776) = 18446742974197923840 +ceiling2(2199023255552, 2199023255552) = 2199023255552, ceiling2(2199023255554, 2199023255552) = 4398046511104, ceiling2(18446741874686296062, 2199023255552) = 18446741874686296064 +ceiling2(4398046511104, 4398046511104) = 4398046511104, ceiling2(4398046511106, 4398046511104) = 8796093022208, ceiling2(18446739675663040510, 4398046511104) = 18446739675663040512 +ceiling2(8796093022208, 8796093022208) = 8796093022208, ceiling2(8796093022210, 8796093022208) = 17592186044416, ceiling2(18446735277616529406, 8796093022208) = 18446735277616529408 +ceiling2(17592186044416, 17592186044416) = 17592186044416, ceiling2(17592186044418, 17592186044416) = 35184372088832, ceiling2(18446726481523507198, 17592186044416) = 18446726481523507200 +ceiling2(35184372088832, 35184372088832) = 35184372088832, ceiling2(35184372088834, 35184372088832) = 70368744177664, ceiling2(18446708889337462782, 35184372088832) = 18446708889337462784 +ceiling2(70368744177664, 70368744177664) = 70368744177664, ceiling2(70368744177666, 70368744177664) = 140737488355328, ceiling2(18446673704965373950, 70368744177664) = 18446673704965373952 +ceiling2(140737488355328, 140737488355328) = 140737488355328, ceiling2(140737488355330, 140737488355328) = 281474976710656, ceiling2(18446603336221196286, 140737488355328) = 18446603336221196288 +ceiling2(281474976710656, 281474976710656) = 281474976710656, ceiling2(281474976710658, 281474976710656) = 562949953421312, ceiling2(18446462598732840958, 281474976710656) = 18446462598732840960 +ceiling2(562949953421312, 562949953421312) = 562949953421312, ceiling2(562949953421314, 562949953421312) = 1125899906842624, ceiling2(18446181123756130302, 562949953421312) = 18446181123756130304 +ceiling2(1125899906842624, 1125899906842624) = 1125899906842624, ceiling2(1125899906842626, 1125899906842624) = 2251799813685248, ceiling2(18445618173802708990, 1125899906842624) = 18445618173802708992 +ceiling2(2251799813685248, 2251799813685248) = 2251799813685248, ceiling2(2251799813685250, 2251799813685248) = 4503599627370496, ceiling2(18444492273895866366, 2251799813685248) = 18444492273895866368 +ceiling2(4503599627370496, 4503599627370496) = 4503599627370496, ceiling2(4503599627370498, 4503599627370496) = 9007199254740992, ceiling2(18442240474082181118, 4503599627370496) = 18442240474082181120 +ceiling2(9007199254740992, 9007199254740992) = 9007199254740992, ceiling2(9007199254740994, 9007199254740992) = 18014398509481984, ceiling2(18437736874454810622, 9007199254740992) = 18437736874454810624 +ceiling2(18014398509481984, 18014398509481984) = 18014398509481984, ceiling2(18014398509481986, 18014398509481984) = 36028797018963968, ceiling2(18428729675200069630, 18014398509481984) = 18428729675200069632 +ceiling2(36028797018963968, 36028797018963968) = 36028797018963968, ceiling2(36028797018963970, 36028797018963968) = 72057594037927936, ceiling2(18410715276690587646, 36028797018963968) = 18410715276690587648 +ceiling2(72057594037927936, 72057594037927936) = 72057594037927936, ceiling2(72057594037927938, 72057594037927936) = 144115188075855872, ceiling2(18374686479671623678, 72057594037927936) = 18374686479671623680 +ceiling2(144115188075855872, 144115188075855872) = 144115188075855872, ceiling2(144115188075855874, 144115188075855872) = 288230376151711744, ceiling2(18302628885633695742, 144115188075855872) = 18302628885633695744 +ceiling2(288230376151711744, 288230376151711744) = 288230376151711744, ceiling2(288230376151711746, 288230376151711744) = 576460752303423488, ceiling2(18158513697557839870, 288230376151711744) = 18158513697557839872 +ceiling2(576460752303423488, 576460752303423488) = 576460752303423488, ceiling2(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling2(17870283321406128126, 576460752303423488) = 17870283321406128128 +ceiling2(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling2(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling2(17293822569102704638, 1152921504606846976) = 17293822569102704640 +ceiling2(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling2(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling2(16140901064495857662, 2305843009213693952) = 16140901064495857664 +ceiling2(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling2(4611686018427387906, 4611686018427387904) = 9223372036854775808, ceiling2(13835058055282163710, 4611686018427387904) = 13835058055282163712 +ceiling2(9223372036854775808, 9223372036854775808) = 9223372036854775808, ceiling2(9223372036854775810, 9223372036854775808) = 0, ceiling2(9223372036854775806, 9223372036854775808) = 9223372036854775808 + + +ceiling + +signed char +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(-128, -128) = 2, ceiling(-126, -128) = 1, ceiling(126, -128) = 0 + +unsigned char +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(253, 1) = 253 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(252, 2) = 126 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(250, 4) = 63 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(246, 8) = 31 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(238, 16) = 15 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(222, 32) = 7 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(190, 64) = 3 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(126, 128) = 1 + +short int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(-130, 128) = 0 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(-258, 256) = 0 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(-514, 512) = 0 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(-1026, 1024) = 0 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(-2050, 2048) = 0 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(-4098, 4096) = 0 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(-8194, 8192) = 0 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(-16386, 16384) = 0 +ceiling(-32768, -32768) = 2, ceiling(-32766, -32768) = 1, ceiling(32766, -32768) = 0 + +unsigned short int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(65533, 1) = 65533 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(65532, 2) = 32766 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(65530, 4) = 16383 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(65526, 8) = 8191 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(65518, 16) = 4095 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(65502, 32) = 2047 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(65470, 64) = 1023 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(65406, 128) = 511 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(65278, 256) = 255 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(65022, 512) = 127 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(64510, 1024) = 63 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(63486, 2048) = 31 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(61438, 4096) = 15 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(57342, 8192) = 7 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(49150, 16384) = 3 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(32766, 32768) = 1 + +int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(-130, 128) = 0 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(-258, 256) = 0 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(-514, 512) = 0 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(-1026, 1024) = 0 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(-2050, 2048) = 0 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(-4098, 4096) = 0 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(-8194, 8192) = 0 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(-16386, 16384) = 0 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(-32770, 32768) = 0 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(-65538, 65536) = 0 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(-131074, 131072) = 0 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(-262146, 262144) = 0 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(-524290, 524288) = 0 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(-1048578, 1048576) = 0 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(-2097154, 2097152) = 0 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(-4194306, 4194304) = 0 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(-8388610, 8388608) = 0 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(-16777218, 16777216) = 0 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(-33554434, 33554432) = 0 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(-67108866, 67108864) = 0 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(-134217730, 134217728) = 0 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(-268435458, 268435456) = 0 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(-536870914, 536870912) = 0 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = -1, ceiling(-1073741826, 1073741824) = 0 +ceiling(-2147483648, -2147483648) = 0, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = 0 + +unsigned int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(4294967293, 1) = 4294967293 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(4294967292, 2) = 2147483646 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(4294967290, 4) = 1073741823 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(4294967286, 8) = 536870911 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(4294967278, 16) = 268435455 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(4294967262, 32) = 134217727 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(4294967230, 64) = 67108863 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(4294967166, 128) = 33554431 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(4294967038, 256) = 16777215 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(4294966782, 512) = 8388607 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(4294966270, 1024) = 4194303 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(4294965246, 2048) = 2097151 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(4294963198, 4096) = 1048575 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(4294959102, 8192) = 524287 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(4294950910, 16384) = 262143 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(4294934526, 32768) = 131071 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(4294901758, 65536) = 65535 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(4294836222, 131072) = 32767 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(4294705150, 262144) = 16383 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(4294443006, 524288) = 8191 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(4293918718, 1048576) = 4095 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(4292870142, 2097152) = 2047 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(4290772990, 4194304) = 1023 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(4286578686, 8388608) = 511 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(4278190078, 16777216) = 255 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(4261412862, 33554432) = 127 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(4227858430, 67108864) = 63 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(4160749566, 134217728) = 31 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(4026531838, 268435456) = 15 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(3758096382, 536870912) = 7 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(3221225470, 1073741824) = 3 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 0, ceiling(2147483646, 2147483648) = 1 + +long int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(-130, 128) = 0 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(-258, 256) = 0 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(-514, 512) = 0 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(-1026, 1024) = 0 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(-2050, 2048) = 0 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(-4098, 4096) = 0 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(-8194, 8192) = 0 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(-16386, 16384) = 0 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(-32770, 32768) = 0 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(-65538, 65536) = 0 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(-131074, 131072) = 0 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(-262146, 262144) = 0 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(-524290, 524288) = 0 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(-1048578, 1048576) = 0 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(-2097154, 2097152) = 0 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(-4194306, 4194304) = 0 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(-8388610, 8388608) = 0 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(-16777218, 16777216) = 0 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(-33554434, 33554432) = 0 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(-67108866, 67108864) = 0 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(-134217730, 134217728) = 0 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(-268435458, 268435456) = 0 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(-536870914, 536870912) = 0 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(-1073741826, 1073741824) = 0 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 2, ceiling(-2147483650, 2147483648) = 0 +ceiling(4294967296, 4294967296) = 1, ceiling(4294967298, 4294967296) = 2, ceiling(-4294967298, 4294967296) = 0 +ceiling(8589934592, 8589934592) = 1, ceiling(8589934594, 8589934592) = 2, ceiling(-8589934594, 8589934592) = 0 +ceiling(17179869184, 17179869184) = 1, ceiling(17179869186, 17179869184) = 2, ceiling(-17179869186, 17179869184) = 0 +ceiling(34359738368, 34359738368) = 1, ceiling(34359738370, 34359738368) = 2, ceiling(-34359738370, 34359738368) = 0 +ceiling(68719476736, 68719476736) = 1, ceiling(68719476738, 68719476736) = 2, ceiling(-68719476738, 68719476736) = 0 +ceiling(137438953472, 137438953472) = 1, ceiling(137438953474, 137438953472) = 2, ceiling(-137438953474, 137438953472) = 0 +ceiling(274877906944, 274877906944) = 1, ceiling(274877906946, 274877906944) = 2, ceiling(-274877906946, 274877906944) = 0 +ceiling(549755813888, 549755813888) = 1, ceiling(549755813890, 549755813888) = 2, ceiling(-549755813890, 549755813888) = 0 +ceiling(1099511627776, 1099511627776) = 1, ceiling(1099511627778, 1099511627776) = 2, ceiling(-1099511627778, 1099511627776) = 0 +ceiling(2199023255552, 2199023255552) = 1, ceiling(2199023255554, 2199023255552) = 2, ceiling(-2199023255554, 2199023255552) = 0 +ceiling(4398046511104, 4398046511104) = 1, ceiling(4398046511106, 4398046511104) = 2, ceiling(-4398046511106, 4398046511104) = 0 +ceiling(8796093022208, 8796093022208) = 1, ceiling(8796093022210, 8796093022208) = 2, ceiling(-8796093022210, 8796093022208) = 0 +ceiling(17592186044416, 17592186044416) = 1, ceiling(17592186044418, 17592186044416) = 2, ceiling(-17592186044418, 17592186044416) = 0 +ceiling(35184372088832, 35184372088832) = 1, ceiling(35184372088834, 35184372088832) = 2, ceiling(-35184372088834, 35184372088832) = 0 +ceiling(70368744177664, 70368744177664) = 1, ceiling(70368744177666, 70368744177664) = 2, ceiling(-70368744177666, 70368744177664) = 0 +ceiling(140737488355328, 140737488355328) = 1, ceiling(140737488355330, 140737488355328) = 2, ceiling(-140737488355330, 140737488355328) = 0 +ceiling(281474976710656, 281474976710656) = 1, ceiling(281474976710658, 281474976710656) = 2, ceiling(-281474976710658, 281474976710656) = 0 +ceiling(562949953421312, 562949953421312) = 1, ceiling(562949953421314, 562949953421312) = 2, ceiling(-562949953421314, 562949953421312) = 0 +ceiling(1125899906842624, 1125899906842624) = 1, ceiling(1125899906842626, 1125899906842624) = 2, ceiling(-1125899906842626, 1125899906842624) = 0 +ceiling(2251799813685248, 2251799813685248) = 1, ceiling(2251799813685250, 2251799813685248) = 2, ceiling(-2251799813685250, 2251799813685248) = 0 +ceiling(4503599627370496, 4503599627370496) = 1, ceiling(4503599627370498, 4503599627370496) = 2, ceiling(-4503599627370498, 4503599627370496) = 0 +ceiling(9007199254740992, 9007199254740992) = 1, ceiling(9007199254740994, 9007199254740992) = 2, ceiling(-9007199254740994, 9007199254740992) = 0 +ceiling(18014398509481984, 18014398509481984) = 1, ceiling(18014398509481986, 18014398509481984) = 2, ceiling(-18014398509481986, 18014398509481984) = 0 +ceiling(36028797018963968, 36028797018963968) = 1, ceiling(36028797018963970, 36028797018963968) = 2, ceiling(-36028797018963970, 36028797018963968) = 0 +ceiling(72057594037927936, 72057594037927936) = 1, ceiling(72057594037927938, 72057594037927936) = 2, ceiling(-72057594037927938, 72057594037927936) = 0 +ceiling(144115188075855872, 144115188075855872) = 1, ceiling(144115188075855874, 144115188075855872) = 2, ceiling(-144115188075855874, 144115188075855872) = 0 +ceiling(288230376151711744, 288230376151711744) = 1, ceiling(288230376151711746, 288230376151711744) = 2, ceiling(-288230376151711746, 288230376151711744) = 0 +ceiling(576460752303423488, 576460752303423488) = 1, ceiling(576460752303423490, 576460752303423488) = 2, ceiling(-576460752303423490, 576460752303423488) = 0 +ceiling(1152921504606846976, 1152921504606846976) = 1, ceiling(1152921504606846978, 1152921504606846976) = 2, ceiling(-1152921504606846978, 1152921504606846976) = 0 +ceiling(2305843009213693952, 2305843009213693952) = 1, ceiling(2305843009213693954, 2305843009213693952) = 2, ceiling(-2305843009213693954, 2305843009213693952) = 0 +ceiling(4611686018427387904, 4611686018427387904) = 1, ceiling(4611686018427387906, 4611686018427387904) = -1, ceiling(-4611686018427387906, 4611686018427387904) = 0 +ceiling(-9223372036854775808, -9223372036854775808) = 0, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = 0 + +unsigned long int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(18446744073709551613, 1) = 18446744073709551613 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(18446744073709551612, 2) = 9223372036854775806 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(18446744073709551610, 4) = 4611686018427387903 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(18446744073709551606, 8) = 2305843009213693951 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(18446744073709551598, 16) = 1152921504606846975 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(18446744073709551582, 32) = 576460752303423487 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(18446744073709551550, 64) = 288230376151711743 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(18446744073709551486, 128) = 144115188075855871 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(18446744073709551358, 256) = 72057594037927935 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(18446744073709551102, 512) = 36028797018963967 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(18446744073709550590, 1024) = 18014398509481983 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(18446744073709549566, 2048) = 9007199254740991 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(18446744073709547518, 4096) = 4503599627370495 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(18446744073709543422, 8192) = 2251799813685247 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(18446744073709535230, 16384) = 1125899906842623 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(18446744073709518846, 32768) = 562949953421311 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(18446744073709486078, 65536) = 281474976710655 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(18446744073709420542, 131072) = 140737488355327 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(18446744073709289470, 262144) = 70368744177663 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(18446744073709027326, 524288) = 35184372088831 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(18446744073708503038, 1048576) = 17592186044415 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(18446744073707454462, 2097152) = 8796093022207 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(18446744073705357310, 4194304) = 4398046511103 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(18446744073701163006, 8388608) = 2199023255551 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(18446744073692774398, 16777216) = 1099511627775 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(18446744073675997182, 33554432) = 549755813887 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(18446744073642442750, 67108864) = 274877906943 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(18446744073575333886, 134217728) = 137438953471 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(18446744073441116158, 268435456) = 68719476735 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(18446744073172680702, 536870912) = 34359738367 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(18446744072635809790, 1073741824) = 17179869183 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 2, ceiling(18446744071562067966, 2147483648) = 8589934591 +ceiling(4294967296, 4294967296) = 1, ceiling(4294967298, 4294967296) = 2, ceiling(18446744069414584318, 4294967296) = 4294967295 +ceiling(8589934592, 8589934592) = 1, ceiling(8589934594, 8589934592) = 2, ceiling(18446744065119617022, 8589934592) = 2147483647 +ceiling(17179869184, 17179869184) = 1, ceiling(17179869186, 17179869184) = 2, ceiling(18446744056529682430, 17179869184) = 1073741823 +ceiling(34359738368, 34359738368) = 1, ceiling(34359738370, 34359738368) = 2, ceiling(18446744039349813246, 34359738368) = 536870911 +ceiling(68719476736, 68719476736) = 1, ceiling(68719476738, 68719476736) = 2, ceiling(18446744004990074878, 68719476736) = 268435455 +ceiling(137438953472, 137438953472) = 1, ceiling(137438953474, 137438953472) = 2, ceiling(18446743936270598142, 137438953472) = 134217727 +ceiling(274877906944, 274877906944) = 1, ceiling(274877906946, 274877906944) = 2, ceiling(18446743798831644670, 274877906944) = 67108863 +ceiling(549755813888, 549755813888) = 1, ceiling(549755813890, 549755813888) = 2, ceiling(18446743523953737726, 549755813888) = 33554431 +ceiling(1099511627776, 1099511627776) = 1, ceiling(1099511627778, 1099511627776) = 2, ceiling(18446742974197923838, 1099511627776) = 16777215 +ceiling(2199023255552, 2199023255552) = 1, ceiling(2199023255554, 2199023255552) = 2, ceiling(18446741874686296062, 2199023255552) = 8388607 +ceiling(4398046511104, 4398046511104) = 1, ceiling(4398046511106, 4398046511104) = 2, ceiling(18446739675663040510, 4398046511104) = 4194303 +ceiling(8796093022208, 8796093022208) = 1, ceiling(8796093022210, 8796093022208) = 2, ceiling(18446735277616529406, 8796093022208) = 2097151 +ceiling(17592186044416, 17592186044416) = 1, ceiling(17592186044418, 17592186044416) = 2, ceiling(18446726481523507198, 17592186044416) = 1048575 +ceiling(35184372088832, 35184372088832) = 1, ceiling(35184372088834, 35184372088832) = 2, ceiling(18446708889337462782, 35184372088832) = 524287 +ceiling(70368744177664, 70368744177664) = 1, ceiling(70368744177666, 70368744177664) = 2, ceiling(18446673704965373950, 70368744177664) = 262143 +ceiling(140737488355328, 140737488355328) = 1, ceiling(140737488355330, 140737488355328) = 2, ceiling(18446603336221196286, 140737488355328) = 131071 +ceiling(281474976710656, 281474976710656) = 1, ceiling(281474976710658, 281474976710656) = 2, ceiling(18446462598732840958, 281474976710656) = 65535 +ceiling(562949953421312, 562949953421312) = 1, ceiling(562949953421314, 562949953421312) = 2, ceiling(18446181123756130302, 562949953421312) = 32767 +ceiling(1125899906842624, 1125899906842624) = 1, ceiling(1125899906842626, 1125899906842624) = 2, ceiling(18445618173802708990, 1125899906842624) = 16383 +ceiling(2251799813685248, 2251799813685248) = 1, ceiling(2251799813685250, 2251799813685248) = 2, ceiling(18444492273895866366, 2251799813685248) = 8191 +ceiling(4503599627370496, 4503599627370496) = 1, ceiling(4503599627370498, 4503599627370496) = 2, ceiling(18442240474082181118, 4503599627370496) = 4095 +ceiling(9007199254740992, 9007199254740992) = 1, ceiling(9007199254740994, 9007199254740992) = 2, ceiling(18437736874454810622, 9007199254740992) = 2047 +ceiling(18014398509481984, 18014398509481984) = 1, ceiling(18014398509481986, 18014398509481984) = 2, ceiling(18428729675200069630, 18014398509481984) = 1023 +ceiling(36028797018963968, 36028797018963968) = 1, ceiling(36028797018963970, 36028797018963968) = 2, ceiling(18410715276690587646, 36028797018963968) = 511 +ceiling(72057594037927936, 72057594037927936) = 1, ceiling(72057594037927938, 72057594037927936) = 2, ceiling(18374686479671623678, 72057594037927936) = 255 +ceiling(144115188075855872, 144115188075855872) = 1, ceiling(144115188075855874, 144115188075855872) = 2, ceiling(18302628885633695742, 144115188075855872) = 127 +ceiling(288230376151711744, 288230376151711744) = 1, ceiling(288230376151711746, 288230376151711744) = 2, ceiling(18158513697557839870, 288230376151711744) = 63 +ceiling(576460752303423488, 576460752303423488) = 1, ceiling(576460752303423490, 576460752303423488) = 2, ceiling(17870283321406128126, 576460752303423488) = 31 +ceiling(1152921504606846976, 1152921504606846976) = 1, ceiling(1152921504606846978, 1152921504606846976) = 2, ceiling(17293822569102704638, 1152921504606846976) = 15 +ceiling(2305843009213693952, 2305843009213693952) = 1, ceiling(2305843009213693954, 2305843009213693952) = 2, ceiling(16140901064495857662, 2305843009213693952) = 7 +ceiling(4611686018427387904, 4611686018427387904) = 1, ceiling(4611686018427387906, 4611686018427387904) = 2, ceiling(13835058055282163710, 4611686018427387904) = 3 +ceiling(9223372036854775808, 9223372036854775808) = 1, ceiling(9223372036854775810, 9223372036854775808) = 0, ceiling(9223372036854775806, 9223372036854775808) = 1 + +long long int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(-130, 128) = 0 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(-258, 256) = 0 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(-514, 512) = 0 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(-1026, 1024) = 0 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(-2050, 2048) = 0 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(-4098, 4096) = 0 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(-8194, 8192) = 0 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(-16386, 16384) = 0 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(-32770, 32768) = 0 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(-65538, 65536) = 0 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(-131074, 131072) = 0 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(-262146, 262144) = 0 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(-524290, 524288) = 0 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(-1048578, 1048576) = 0 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(-2097154, 2097152) = 0 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(-4194306, 4194304) = 0 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(-8388610, 8388608) = 0 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(-16777218, 16777216) = 0 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(-33554434, 33554432) = 0 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(-67108866, 67108864) = 0 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(-134217730, 134217728) = 0 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(-268435458, 268435456) = 0 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(-536870914, 536870912) = 0 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(-1073741826, 1073741824) = 0 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 2, ceiling(-2147483650, 2147483648) = 0 +ceiling(4294967296, 4294967296) = 1, ceiling(4294967298, 4294967296) = 2, ceiling(-4294967298, 4294967296) = 0 +ceiling(8589934592, 8589934592) = 1, ceiling(8589934594, 8589934592) = 2, ceiling(-8589934594, 8589934592) = 0 +ceiling(17179869184, 17179869184) = 1, ceiling(17179869186, 17179869184) = 2, ceiling(-17179869186, 17179869184) = 0 +ceiling(34359738368, 34359738368) = 1, ceiling(34359738370, 34359738368) = 2, ceiling(-34359738370, 34359738368) = 0 +ceiling(68719476736, 68719476736) = 1, ceiling(68719476738, 68719476736) = 2, ceiling(-68719476738, 68719476736) = 0 +ceiling(137438953472, 137438953472) = 1, ceiling(137438953474, 137438953472) = 2, ceiling(-137438953474, 137438953472) = 0 +ceiling(274877906944, 274877906944) = 1, ceiling(274877906946, 274877906944) = 2, ceiling(-274877906946, 274877906944) = 0 +ceiling(549755813888, 549755813888) = 1, ceiling(549755813890, 549755813888) = 2, ceiling(-549755813890, 549755813888) = 0 +ceiling(1099511627776, 1099511627776) = 1, ceiling(1099511627778, 1099511627776) = 2, ceiling(-1099511627778, 1099511627776) = 0 +ceiling(2199023255552, 2199023255552) = 1, ceiling(2199023255554, 2199023255552) = 2, ceiling(-2199023255554, 2199023255552) = 0 +ceiling(4398046511104, 4398046511104) = 1, ceiling(4398046511106, 4398046511104) = 2, ceiling(-4398046511106, 4398046511104) = 0 +ceiling(8796093022208, 8796093022208) = 1, ceiling(8796093022210, 8796093022208) = 2, ceiling(-8796093022210, 8796093022208) = 0 +ceiling(17592186044416, 17592186044416) = 1, ceiling(17592186044418, 17592186044416) = 2, ceiling(-17592186044418, 17592186044416) = 0 +ceiling(35184372088832, 35184372088832) = 1, ceiling(35184372088834, 35184372088832) = 2, ceiling(-35184372088834, 35184372088832) = 0 +ceiling(70368744177664, 70368744177664) = 1, ceiling(70368744177666, 70368744177664) = 2, ceiling(-70368744177666, 70368744177664) = 0 +ceiling(140737488355328, 140737488355328) = 1, ceiling(140737488355330, 140737488355328) = 2, ceiling(-140737488355330, 140737488355328) = 0 +ceiling(281474976710656, 281474976710656) = 1, ceiling(281474976710658, 281474976710656) = 2, ceiling(-281474976710658, 281474976710656) = 0 +ceiling(562949953421312, 562949953421312) = 1, ceiling(562949953421314, 562949953421312) = 2, ceiling(-562949953421314, 562949953421312) = 0 +ceiling(1125899906842624, 1125899906842624) = 1, ceiling(1125899906842626, 1125899906842624) = 2, ceiling(-1125899906842626, 1125899906842624) = 0 +ceiling(2251799813685248, 2251799813685248) = 1, ceiling(2251799813685250, 2251799813685248) = 2, ceiling(-2251799813685250, 2251799813685248) = 0 +ceiling(4503599627370496, 4503599627370496) = 1, ceiling(4503599627370498, 4503599627370496) = 2, ceiling(-4503599627370498, 4503599627370496) = 0 +ceiling(9007199254740992, 9007199254740992) = 1, ceiling(9007199254740994, 9007199254740992) = 2, ceiling(-9007199254740994, 9007199254740992) = 0 +ceiling(18014398509481984, 18014398509481984) = 1, ceiling(18014398509481986, 18014398509481984) = 2, ceiling(-18014398509481986, 18014398509481984) = 0 +ceiling(36028797018963968, 36028797018963968) = 1, ceiling(36028797018963970, 36028797018963968) = 2, ceiling(-36028797018963970, 36028797018963968) = 0 +ceiling(72057594037927936, 72057594037927936) = 1, ceiling(72057594037927938, 72057594037927936) = 2, ceiling(-72057594037927938, 72057594037927936) = 0 +ceiling(144115188075855872, 144115188075855872) = 1, ceiling(144115188075855874, 144115188075855872) = 2, ceiling(-144115188075855874, 144115188075855872) = 0 +ceiling(288230376151711744, 288230376151711744) = 1, ceiling(288230376151711746, 288230376151711744) = 2, ceiling(-288230376151711746, 288230376151711744) = 0 +ceiling(576460752303423488, 576460752303423488) = 1, ceiling(576460752303423490, 576460752303423488) = 2, ceiling(-576460752303423490, 576460752303423488) = 0 +ceiling(1152921504606846976, 1152921504606846976) = 1, ceiling(1152921504606846978, 1152921504606846976) = 2, ceiling(-1152921504606846978, 1152921504606846976) = 0 +ceiling(2305843009213693952, 2305843009213693952) = 1, ceiling(2305843009213693954, 2305843009213693952) = 2, ceiling(-2305843009213693954, 2305843009213693952) = 0 +ceiling(4611686018427387904, 4611686018427387904) = 1, ceiling(4611686018427387906, 4611686018427387904) = -1, ceiling(-4611686018427387906, 4611686018427387904) = 0 +ceiling(-9223372036854775808, -9223372036854775808) = 0, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = 0 + +unsigned long long int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(18446744073709551613, 1) = 18446744073709551613 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(18446744073709551612, 2) = 9223372036854775806 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(18446744073709551610, 4) = 4611686018427387903 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(18446744073709551606, 8) = 2305843009213693951 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(18446744073709551598, 16) = 1152921504606846975 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(18446744073709551582, 32) = 576460752303423487 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(18446744073709551550, 64) = 288230376151711743 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(18446744073709551486, 128) = 144115188075855871 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(18446744073709551358, 256) = 72057594037927935 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(18446744073709551102, 512) = 36028797018963967 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(18446744073709550590, 1024) = 18014398509481983 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(18446744073709549566, 2048) = 9007199254740991 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(18446744073709547518, 4096) = 4503599627370495 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(18446744073709543422, 8192) = 2251799813685247 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(18446744073709535230, 16384) = 1125899906842623 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(18446744073709518846, 32768) = 562949953421311 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(18446744073709486078, 65536) = 281474976710655 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(18446744073709420542, 131072) = 140737488355327 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(18446744073709289470, 262144) = 70368744177663 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(18446744073709027326, 524288) = 35184372088831 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(18446744073708503038, 1048576) = 17592186044415 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(18446744073707454462, 2097152) = 8796093022207 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(18446744073705357310, 4194304) = 4398046511103 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(18446744073701163006, 8388608) = 2199023255551 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(18446744073692774398, 16777216) = 1099511627775 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(18446744073675997182, 33554432) = 549755813887 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(18446744073642442750, 67108864) = 274877906943 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(18446744073575333886, 134217728) = 137438953471 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(18446744073441116158, 268435456) = 68719476735 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(18446744073172680702, 536870912) = 34359738367 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(18446744072635809790, 1073741824) = 17179869183 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 2, ceiling(18446744071562067966, 2147483648) = 8589934591 +ceiling(4294967296, 4294967296) = 1, ceiling(4294967298, 4294967296) = 2, ceiling(18446744069414584318, 4294967296) = 4294967295 +ceiling(8589934592, 8589934592) = 1, ceiling(8589934594, 8589934592) = 2, ceiling(18446744065119617022, 8589934592) = 2147483647 +ceiling(17179869184, 17179869184) = 1, ceiling(17179869186, 17179869184) = 2, ceiling(18446744056529682430, 17179869184) = 1073741823 +ceiling(34359738368, 34359738368) = 1, ceiling(34359738370, 34359738368) = 2, ceiling(18446744039349813246, 34359738368) = 536870911 +ceiling(68719476736, 68719476736) = 1, ceiling(68719476738, 68719476736) = 2, ceiling(18446744004990074878, 68719476736) = 268435455 +ceiling(137438953472, 137438953472) = 1, ceiling(137438953474, 137438953472) = 2, ceiling(18446743936270598142, 137438953472) = 134217727 +ceiling(274877906944, 274877906944) = 1, ceiling(274877906946, 274877906944) = 2, ceiling(18446743798831644670, 274877906944) = 67108863 +ceiling(549755813888, 549755813888) = 1, ceiling(549755813890, 549755813888) = 2, ceiling(18446743523953737726, 549755813888) = 33554431 +ceiling(1099511627776, 1099511627776) = 1, ceiling(1099511627778, 1099511627776) = 2, ceiling(18446742974197923838, 1099511627776) = 16777215 +ceiling(2199023255552, 2199023255552) = 1, ceiling(2199023255554, 2199023255552) = 2, ceiling(18446741874686296062, 2199023255552) = 8388607 +ceiling(4398046511104, 4398046511104) = 1, ceiling(4398046511106, 4398046511104) = 2, ceiling(18446739675663040510, 4398046511104) = 4194303 +ceiling(8796093022208, 8796093022208) = 1, ceiling(8796093022210, 8796093022208) = 2, ceiling(18446735277616529406, 8796093022208) = 2097151 +ceiling(17592186044416, 17592186044416) = 1, ceiling(17592186044418, 17592186044416) = 2, ceiling(18446726481523507198, 17592186044416) = 1048575 +ceiling(35184372088832, 35184372088832) = 1, ceiling(35184372088834, 35184372088832) = 2, ceiling(18446708889337462782, 35184372088832) = 524287 +ceiling(70368744177664, 70368744177664) = 1, ceiling(70368744177666, 70368744177664) = 2, ceiling(18446673704965373950, 70368744177664) = 262143 +ceiling(140737488355328, 140737488355328) = 1, ceiling(140737488355330, 140737488355328) = 2, ceiling(18446603336221196286, 140737488355328) = 131071 +ceiling(281474976710656, 281474976710656) = 1, ceiling(281474976710658, 281474976710656) = 2, ceiling(18446462598732840958, 281474976710656) = 65535 +ceiling(562949953421312, 562949953421312) = 1, ceiling(562949953421314, 562949953421312) = 2, ceiling(18446181123756130302, 562949953421312) = 32767 +ceiling(1125899906842624, 1125899906842624) = 1, ceiling(1125899906842626, 1125899906842624) = 2, ceiling(18445618173802708990, 1125899906842624) = 16383 +ceiling(2251799813685248, 2251799813685248) = 1, ceiling(2251799813685250, 2251799813685248) = 2, ceiling(18444492273895866366, 2251799813685248) = 8191 +ceiling(4503599627370496, 4503599627370496) = 1, ceiling(4503599627370498, 4503599627370496) = 2, ceiling(18442240474082181118, 4503599627370496) = 4095 +ceiling(9007199254740992, 9007199254740992) = 1, ceiling(9007199254740994, 9007199254740992) = 2, ceiling(18437736874454810622, 9007199254740992) = 2047 +ceiling(18014398509481984, 18014398509481984) = 1, ceiling(18014398509481986, 18014398509481984) = 2, ceiling(18428729675200069630, 18014398509481984) = 1023 +ceiling(36028797018963968, 36028797018963968) = 1, ceiling(36028797018963970, 36028797018963968) = 2, ceiling(18410715276690587646, 36028797018963968) = 511 +ceiling(72057594037927936, 72057594037927936) = 1, ceiling(72057594037927938, 72057594037927936) = 2, ceiling(18374686479671623678, 72057594037927936) = 255 +ceiling(144115188075855872, 144115188075855872) = 1, ceiling(144115188075855874, 144115188075855872) = 2, ceiling(18302628885633695742, 144115188075855872) = 127 +ceiling(288230376151711744, 288230376151711744) = 1, ceiling(288230376151711746, 288230376151711744) = 2, ceiling(18158513697557839870, 288230376151711744) = 63 +ceiling(576460752303423488, 576460752303423488) = 1, ceiling(576460752303423490, 576460752303423488) = 2, ceiling(17870283321406128126, 576460752303423488) = 31 +ceiling(1152921504606846976, 1152921504606846976) = 1, ceiling(1152921504606846978, 1152921504606846976) = 2, ceiling(17293822569102704638, 1152921504606846976) = 15 +ceiling(2305843009213693952, 2305843009213693952) = 1, ceiling(2305843009213693954, 2305843009213693952) = 2, ceiling(16140901064495857662, 2305843009213693952) = 7 +ceiling(4611686018427387904, 4611686018427387904) = 1, ceiling(4611686018427387906, 4611686018427387904) = 2, ceiling(13835058055282163710, 4611686018427387904) = 3 +ceiling(9223372036854775808, 9223372036854775808) = 1, ceiling(9223372036854775810, 9223372036854775808) = 0, ceiling(9223372036854775806, 9223372036854775808) = 1 + Index: tests/.expect/bitmanip3.x86.txt =================================================================== --- tests/.expect/bitmanip3.x86.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/.expect/bitmanip3.x86.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1665 @@ + +is_pow2 + +signed char +0b00000000 false 0b00001101 false +0b00000001 true 0b00001110 false +0b00000010 true 0b00001111 false +0b00000100 true 0b00010001 false +0b00001000 true 0b00010101 false +0b00010000 true 0b00011101 false +0b00100000 true 0b00101101 false +0b01000000 true 0b01001101 false +0b10000000 true 0b10001101 false + +unsigned char +0b00000000 false 0b00001101 false +0b00000001 true 0b00001110 false +0b00000010 true 0b00001111 false +0b00000100 true 0b00010001 false +0b00001000 true 0b00010101 false +0b00010000 true 0b00011101 false +0b00100000 true 0b00101101 false +0b01000000 true 0b01001101 false +0b10000000 true 0b10001101 false + +short int +0b0000000000000000 false 0b0000000000001101 false +0b0000000000000001 true 0b0000000000001110 false +0b0000000000000010 true 0b0000000000001111 false +0b0000000000000100 true 0b0000000000010001 false +0b0000000000001000 true 0b0000000000010101 false +0b0000000000010000 true 0b0000000000011101 false +0b0000000000100000 true 0b0000000000101101 false +0b0000000001000000 true 0b0000000001001101 false +0b0000000010000000 true 0b0000000010001101 false +0b0000000100000000 true 0b0000000100001101 false +0b0000001000000000 true 0b0000001000001101 false +0b0000010000000000 true 0b0000010000001101 false +0b0000100000000000 true 0b0000100000001101 false +0b0001000000000000 true 0b0001000000001101 false +0b0010000000000000 true 0b0010000000001101 false +0b0100000000000000 true 0b0100000000001101 false +0b1000000000000000 true 0b1000000000001101 false + +unsigned short int +0b0000000000000000 false 0b0000000000001101 false +0b0000000000000001 true 0b0000000000001110 false +0b0000000000000010 true 0b0000000000001111 false +0b0000000000000100 true 0b0000000000010001 false +0b0000000000001000 true 0b0000000000010101 false +0b0000000000010000 true 0b0000000000011101 false +0b0000000000100000 true 0b0000000000101101 false +0b0000000001000000 true 0b0000000001001101 false +0b0000000010000000 true 0b0000000010001101 false +0b0000000100000000 true 0b0000000100001101 false +0b0000001000000000 true 0b0000001000001101 false +0b0000010000000000 true 0b0000010000001101 false +0b0000100000000000 true 0b0000100000001101 false +0b0001000000000000 true 0b0001000000001101 false +0b0010000000000000 true 0b0010000000001101 false +0b0100000000000000 true 0b0100000000001101 false +0b1000000000000000 true 0b1000000000001101 false + +int +0b00000000000000000000000000000000 false 0b00000000000000000000000000001101 false +0b00000000000000000000000000000001 true 0b00000000000000000000000000001110 false +0b00000000000000000000000000000010 true 0b00000000000000000000000000001111 false +0b00000000000000000000000000000100 true 0b00000000000000000000000000010001 false +0b00000000000000000000000000001000 true 0b00000000000000000000000000010101 false +0b00000000000000000000000000010000 true 0b00000000000000000000000000011101 false +0b00000000000000000000000000100000 true 0b00000000000000000000000000101101 false +0b00000000000000000000000001000000 true 0b00000000000000000000000001001101 false +0b00000000000000000000000010000000 true 0b00000000000000000000000010001101 false +0b00000000000000000000000100000000 true 0b00000000000000000000000100001101 false +0b00000000000000000000001000000000 true 0b00000000000000000000001000001101 false +0b00000000000000000000010000000000 true 0b00000000000000000000010000001101 false +0b00000000000000000000100000000000 true 0b00000000000000000000100000001101 false +0b00000000000000000001000000000000 true 0b00000000000000000001000000001101 false +0b00000000000000000010000000000000 true 0b00000000000000000010000000001101 false +0b00000000000000000100000000000000 true 0b00000000000000000100000000001101 false +0b00000000000000001000000000000000 true 0b00000000000000001000000000001101 false +0b00000000000000010000000000000000 true 0b00000000000000010000000000001101 false +0b00000000000000100000000000000000 true 0b00000000000000100000000000001101 false +0b00000000000001000000000000000000 true 0b00000000000001000000000000001101 false +0b00000000000010000000000000000000 true 0b00000000000010000000000000001101 false +0b00000000000100000000000000000000 true 0b00000000000100000000000000001101 false +0b00000000001000000000000000000000 true 0b00000000001000000000000000001101 false +0b00000000010000000000000000000000 true 0b00000000010000000000000000001101 false +0b00000000100000000000000000000000 true 0b00000000100000000000000000001101 false +0b00000001000000000000000000000000 true 0b00000001000000000000000000001101 false +0b00000010000000000000000000000000 true 0b00000010000000000000000000001101 false +0b00000100000000000000000000000000 true 0b00000100000000000000000000001101 false +0b00001000000000000000000000000000 true 0b00001000000000000000000000001101 false +0b00010000000000000000000000000000 true 0b00010000000000000000000000001101 false +0b00100000000000000000000000000000 true 0b00100000000000000000000000001101 false +0b01000000000000000000000000000000 true 0b01000000000000000000000000001101 false +0b10000000000000000000000000000000 true 0b10000000000000000000000000001101 false + +unsigned int +0b00000000000000000000000000000000 false 0b00000000000000000000000000001101 false +0b00000000000000000000000000000001 true 0b00000000000000000000000000001110 false +0b00000000000000000000000000000010 true 0b00000000000000000000000000001111 false +0b00000000000000000000000000000100 true 0b00000000000000000000000000010001 false +0b00000000000000000000000000001000 true 0b00000000000000000000000000010101 false +0b00000000000000000000000000010000 true 0b00000000000000000000000000011101 false +0b00000000000000000000000000100000 true 0b00000000000000000000000000101101 false +0b00000000000000000000000001000000 true 0b00000000000000000000000001001101 false +0b00000000000000000000000010000000 true 0b00000000000000000000000010001101 false +0b00000000000000000000000100000000 true 0b00000000000000000000000100001101 false +0b00000000000000000000001000000000 true 0b00000000000000000000001000001101 false +0b00000000000000000000010000000000 true 0b00000000000000000000010000001101 false +0b00000000000000000000100000000000 true 0b00000000000000000000100000001101 false +0b00000000000000000001000000000000 true 0b00000000000000000001000000001101 false +0b00000000000000000010000000000000 true 0b00000000000000000010000000001101 false +0b00000000000000000100000000000000 true 0b00000000000000000100000000001101 false +0b00000000000000001000000000000000 true 0b00000000000000001000000000001101 false +0b00000000000000010000000000000000 true 0b00000000000000010000000000001101 false +0b00000000000000100000000000000000 true 0b00000000000000100000000000001101 false +0b00000000000001000000000000000000 true 0b00000000000001000000000000001101 false +0b00000000000010000000000000000000 true 0b00000000000010000000000000001101 false +0b00000000000100000000000000000000 true 0b00000000000100000000000000001101 false +0b00000000001000000000000000000000 true 0b00000000001000000000000000001101 false +0b00000000010000000000000000000000 true 0b00000000010000000000000000001101 false +0b00000000100000000000000000000000 true 0b00000000100000000000000000001101 false +0b00000001000000000000000000000000 true 0b00000001000000000000000000001101 false +0b00000010000000000000000000000000 true 0b00000010000000000000000000001101 false +0b00000100000000000000000000000000 true 0b00000100000000000000000000001101 false +0b00001000000000000000000000000000 true 0b00001000000000000000000000001101 false +0b00010000000000000000000000000000 true 0b00010000000000000000000000001101 false +0b00100000000000000000000000000000 true 0b00100000000000000000000000001101 false +0b01000000000000000000000000000000 true 0b01000000000000000000000000001101 false +0b10000000000000000000000000000000 true 0b10000000000000000000000000001101 false + +long int +0b00000000000000000000000000000000 false 0b00000000000000000000000000001101 false +0b00000000000000000000000000000001 true 0b00000000000000000000000000001110 false +0b00000000000000000000000000000010 true 0b00000000000000000000000000001111 false +0b00000000000000000000000000000100 true 0b00000000000000000000000000010001 false +0b00000000000000000000000000001000 true 0b00000000000000000000000000010101 false +0b00000000000000000000000000010000 true 0b00000000000000000000000000011101 false +0b00000000000000000000000000100000 true 0b00000000000000000000000000101101 false +0b00000000000000000000000001000000 true 0b00000000000000000000000001001101 false +0b00000000000000000000000010000000 true 0b00000000000000000000000010001101 false +0b00000000000000000000000100000000 true 0b00000000000000000000000100001101 false +0b00000000000000000000001000000000 true 0b00000000000000000000001000001101 false +0b00000000000000000000010000000000 true 0b00000000000000000000010000001101 false +0b00000000000000000000100000000000 true 0b00000000000000000000100000001101 false +0b00000000000000000001000000000000 true 0b00000000000000000001000000001101 false +0b00000000000000000010000000000000 true 0b00000000000000000010000000001101 false +0b00000000000000000100000000000000 true 0b00000000000000000100000000001101 false +0b00000000000000001000000000000000 true 0b00000000000000001000000000001101 false +0b00000000000000010000000000000000 true 0b00000000000000010000000000001101 false +0b00000000000000100000000000000000 true 0b00000000000000100000000000001101 false +0b00000000000001000000000000000000 true 0b00000000000001000000000000001101 false +0b00000000000010000000000000000000 true 0b00000000000010000000000000001101 false +0b00000000000100000000000000000000 true 0b00000000000100000000000000001101 false +0b00000000001000000000000000000000 true 0b00000000001000000000000000001101 false +0b00000000010000000000000000000000 true 0b00000000010000000000000000001101 false +0b00000000100000000000000000000000 true 0b00000000100000000000000000001101 false +0b00000001000000000000000000000000 true 0b00000001000000000000000000001101 false +0b00000010000000000000000000000000 true 0b00000010000000000000000000001101 false +0b00000100000000000000000000000000 true 0b00000100000000000000000000001101 false +0b00001000000000000000000000000000 true 0b00001000000000000000000000001101 false +0b00010000000000000000000000000000 true 0b00010000000000000000000000001101 false +0b00100000000000000000000000000000 true 0b00100000000000000000000000001101 false +0b01000000000000000000000000000000 true 0b01000000000000000000000000001101 false +0b10000000000000000000000000000000 true 0b10000000000000000000000000001101 false + +unsigned long int +0b00000000000000000000000000000000 false 0b00000000000000000000000000001101 false +0b00000000000000000000000000000001 true 0b00000000000000000000000000001110 false +0b00000000000000000000000000000010 true 0b00000000000000000000000000001111 false +0b00000000000000000000000000000100 true 0b00000000000000000000000000010001 false +0b00000000000000000000000000001000 true 0b00000000000000000000000000010101 false +0b00000000000000000000000000010000 true 0b00000000000000000000000000011101 false +0b00000000000000000000000000100000 true 0b00000000000000000000000000101101 false +0b00000000000000000000000001000000 true 0b00000000000000000000000001001101 false +0b00000000000000000000000010000000 true 0b00000000000000000000000010001101 false +0b00000000000000000000000100000000 true 0b00000000000000000000000100001101 false +0b00000000000000000000001000000000 true 0b00000000000000000000001000001101 false +0b00000000000000000000010000000000 true 0b00000000000000000000010000001101 false +0b00000000000000000000100000000000 true 0b00000000000000000000100000001101 false +0b00000000000000000001000000000000 true 0b00000000000000000001000000001101 false +0b00000000000000000010000000000000 true 0b00000000000000000010000000001101 false +0b00000000000000000100000000000000 true 0b00000000000000000100000000001101 false +0b00000000000000001000000000000000 true 0b00000000000000001000000000001101 false +0b00000000000000010000000000000000 true 0b00000000000000010000000000001101 false +0b00000000000000100000000000000000 true 0b00000000000000100000000000001101 false +0b00000000000001000000000000000000 true 0b00000000000001000000000000001101 false +0b00000000000010000000000000000000 true 0b00000000000010000000000000001101 false +0b00000000000100000000000000000000 true 0b00000000000100000000000000001101 false +0b00000000001000000000000000000000 true 0b00000000001000000000000000001101 false +0b00000000010000000000000000000000 true 0b00000000010000000000000000001101 false +0b00000000100000000000000000000000 true 0b00000000100000000000000000001101 false +0b00000001000000000000000000000000 true 0b00000001000000000000000000001101 false +0b00000010000000000000000000000000 true 0b00000010000000000000000000001101 false +0b00000100000000000000000000000000 true 0b00000100000000000000000000001101 false +0b00001000000000000000000000000000 true 0b00001000000000000000000000001101 false +0b00010000000000000000000000000000 true 0b00010000000000000000000000001101 false +0b00100000000000000000000000000000 true 0b00100000000000000000000000001101 false +0b01000000000000000000000000000000 true 0b01000000000000000000000000001101 false +0b10000000000000000000000000000000 true 0b10000000000000000000000000001101 false + +long long int +0b0000000000000000000000000000000000000000000000000000000000000000 false 0b0000000000000000000000000000000000000000000000000000000000001101 false +0b0000000000000000000000000000000000000000000000000000000000000001 true 0b0000000000000000000000000000000000000000000000000000000000001110 false +0b0000000000000000000000000000000000000000000000000000000000000010 true 0b0000000000000000000000000000000000000000000000000000000000001111 false +0b0000000000000000000000000000000000000000000000000000000000000100 true 0b0000000000000000000000000000000000000000000000000000000000010001 false +0b0000000000000000000000000000000000000000000000000000000000001000 true 0b0000000000000000000000000000000000000000000000000000000000010101 false +0b0000000000000000000000000000000000000000000000000000000000010000 true 0b0000000000000000000000000000000000000000000000000000000000011101 false +0b0000000000000000000000000000000000000000000000000000000000100000 true 0b0000000000000000000000000000000000000000000000000000000000101101 false +0b0000000000000000000000000000000000000000000000000000000001000000 true 0b0000000000000000000000000000000000000000000000000000000001001101 false +0b0000000000000000000000000000000000000000000000000000000010000000 true 0b0000000000000000000000000000000000000000000000000000000010001101 false +0b0000000000000000000000000000000000000000000000000000000100000000 true 0b0000000000000000000000000000000000000000000000000000000100001101 false +0b0000000000000000000000000000000000000000000000000000001000000000 true 0b0000000000000000000000000000000000000000000000000000001000001101 false +0b0000000000000000000000000000000000000000000000000000010000000000 true 0b0000000000000000000000000000000000000000000000000000010000001101 false +0b0000000000000000000000000000000000000000000000000000100000000000 true 0b0000000000000000000000000000000000000000000000000000100000001101 false +0b0000000000000000000000000000000000000000000000000001000000000000 true 0b0000000000000000000000000000000000000000000000000001000000001101 false +0b0000000000000000000000000000000000000000000000000010000000000000 true 0b0000000000000000000000000000000000000000000000000010000000001101 false +0b0000000000000000000000000000000000000000000000000100000000000000 true 0b0000000000000000000000000000000000000000000000000100000000001101 false +0b0000000000000000000000000000000000000000000000001000000000000000 true 0b0000000000000000000000000000000000000000000000001000000000001101 false +0b0000000000000000000000000000000000000000000000010000000000000000 true 0b0000000000000000000000000000000000000000000000010000000000001101 false +0b0000000000000000000000000000000000000000000000100000000000000000 true 0b0000000000000000000000000000000000000000000000100000000000001101 false +0b0000000000000000000000000000000000000000000001000000000000000000 true 0b0000000000000000000000000000000000000000000001000000000000001101 false +0b0000000000000000000000000000000000000000000010000000000000000000 true 0b0000000000000000000000000000000000000000000010000000000000001101 false +0b0000000000000000000000000000000000000000000100000000000000000000 true 0b0000000000000000000000000000000000000000000100000000000000001101 false +0b0000000000000000000000000000000000000000001000000000000000000000 true 0b0000000000000000000000000000000000000000001000000000000000001101 false +0b0000000000000000000000000000000000000000010000000000000000000000 true 0b0000000000000000000000000000000000000000010000000000000000001101 false +0b0000000000000000000000000000000000000000100000000000000000000000 true 0b0000000000000000000000000000000000000000100000000000000000001101 false +0b0000000000000000000000000000000000000001000000000000000000000000 true 0b0000000000000000000000000000000000000001000000000000000000001101 false +0b0000000000000000000000000000000000000010000000000000000000000000 true 0b0000000000000000000000000000000000000010000000000000000000001101 false +0b0000000000000000000000000000000000000100000000000000000000000000 true 0b0000000000000000000000000000000000000100000000000000000000001101 false +0b0000000000000000000000000000000000001000000000000000000000000000 true 0b0000000000000000000000000000000000001000000000000000000000001101 false +0b0000000000000000000000000000000000010000000000000000000000000000 true 0b0000000000000000000000000000000000010000000000000000000000001101 false +0b0000000000000000000000000000000000100000000000000000000000000000 true 0b0000000000000000000000000000000000100000000000000000000000001101 false +0b0000000000000000000000000000000001000000000000000000000000000000 true 0b0000000000000000000000000000000001000000000000000000000000001101 false +0b0000000000000000000000000000000010000000000000000000000000000000 true 0b0000000000000000000000000000000010000000000000000000000000001101 false +0b0000000000000000000000000000000100000000000000000000000000000000 true 0b0000000000000000000000000000000100000000000000000000000000001101 false +0b0000000000000000000000000000001000000000000000000000000000000000 true 0b0000000000000000000000000000001000000000000000000000000000001101 false +0b0000000000000000000000000000010000000000000000000000000000000000 true 0b0000000000000000000000000000010000000000000000000000000000001101 false +0b0000000000000000000000000000100000000000000000000000000000000000 true 0b0000000000000000000000000000100000000000000000000000000000001101 false +0b0000000000000000000000000001000000000000000000000000000000000000 true 0b0000000000000000000000000001000000000000000000000000000000001101 false +0b0000000000000000000000000010000000000000000000000000000000000000 true 0b0000000000000000000000000010000000000000000000000000000000001101 false +0b0000000000000000000000000100000000000000000000000000000000000000 true 0b0000000000000000000000000100000000000000000000000000000000001101 false +0b0000000000000000000000001000000000000000000000000000000000000000 true 0b0000000000000000000000001000000000000000000000000000000000001101 false +0b0000000000000000000000010000000000000000000000000000000000000000 true 0b0000000000000000000000010000000000000000000000000000000000001101 false +0b0000000000000000000000100000000000000000000000000000000000000000 true 0b0000000000000000000000100000000000000000000000000000000000001101 false +0b0000000000000000000001000000000000000000000000000000000000000000 true 0b0000000000000000000001000000000000000000000000000000000000001101 false +0b0000000000000000000010000000000000000000000000000000000000000000 true 0b0000000000000000000010000000000000000000000000000000000000001101 false +0b0000000000000000000100000000000000000000000000000000000000000000 true 0b0000000000000000000100000000000000000000000000000000000000001101 false +0b0000000000000000001000000000000000000000000000000000000000000000 true 0b0000000000000000001000000000000000000000000000000000000000001101 false +0b0000000000000000010000000000000000000000000000000000000000000000 true 0b0000000000000000010000000000000000000000000000000000000000001101 false +0b0000000000000000100000000000000000000000000000000000000000000000 true 0b0000000000000000100000000000000000000000000000000000000000001101 false +0b0000000000000001000000000000000000000000000000000000000000000000 true 0b0000000000000001000000000000000000000000000000000000000000001101 false +0b0000000000000010000000000000000000000000000000000000000000000000 true 0b0000000000000010000000000000000000000000000000000000000000001101 false +0b0000000000000100000000000000000000000000000000000000000000000000 true 0b0000000000000100000000000000000000000000000000000000000000001101 false +0b0000000000001000000000000000000000000000000000000000000000000000 true 0b0000000000001000000000000000000000000000000000000000000000001101 false +0b0000000000010000000000000000000000000000000000000000000000000000 true 0b0000000000010000000000000000000000000000000000000000000000001101 false +0b0000000000100000000000000000000000000000000000000000000000000000 true 0b0000000000100000000000000000000000000000000000000000000000001101 false +0b0000000001000000000000000000000000000000000000000000000000000000 true 0b0000000001000000000000000000000000000000000000000000000000001101 false +0b0000000010000000000000000000000000000000000000000000000000000000 true 0b0000000010000000000000000000000000000000000000000000000000001101 false +0b0000000100000000000000000000000000000000000000000000000000000000 true 0b0000000100000000000000000000000000000000000000000000000000001101 false +0b0000001000000000000000000000000000000000000000000000000000000000 true 0b0000001000000000000000000000000000000000000000000000000000001101 false +0b0000010000000000000000000000000000000000000000000000000000000000 true 0b0000010000000000000000000000000000000000000000000000000000001101 false +0b0000100000000000000000000000000000000000000000000000000000000000 true 0b0000100000000000000000000000000000000000000000000000000000001101 false +0b0001000000000000000000000000000000000000000000000000000000000000 true 0b0001000000000000000000000000000000000000000000000000000000001101 false +0b0010000000000000000000000000000000000000000000000000000000000000 true 0b0010000000000000000000000000000000000000000000000000000000001101 false +0b0100000000000000000000000000000000000000000000000000000000000000 true 0b0100000000000000000000000000000000000000000000000000000000001101 false +0b1000000000000000000000000000000000000000000000000000000000000000 true 0b1000000000000000000000000000000000000000000000000000000000001101 false + +unsigned long long int +0b0000000000000000000000000000000000000000000000000000000000000000 false 0b0000000000000000000000000000000000000000000000000000000000001101 false +0b0000000000000000000000000000000000000000000000000000000000000001 true 0b0000000000000000000000000000000000000000000000000000000000001110 false +0b0000000000000000000000000000000000000000000000000000000000000010 true 0b0000000000000000000000000000000000000000000000000000000000001111 false +0b0000000000000000000000000000000000000000000000000000000000000100 true 0b0000000000000000000000000000000000000000000000000000000000010001 false +0b0000000000000000000000000000000000000000000000000000000000001000 true 0b0000000000000000000000000000000000000000000000000000000000010101 false +0b0000000000000000000000000000000000000000000000000000000000010000 true 0b0000000000000000000000000000000000000000000000000000000000011101 false +0b0000000000000000000000000000000000000000000000000000000000100000 true 0b0000000000000000000000000000000000000000000000000000000000101101 false +0b0000000000000000000000000000000000000000000000000000000001000000 true 0b0000000000000000000000000000000000000000000000000000000001001101 false +0b0000000000000000000000000000000000000000000000000000000010000000 true 0b0000000000000000000000000000000000000000000000000000000010001101 false +0b0000000000000000000000000000000000000000000000000000000100000000 true 0b0000000000000000000000000000000000000000000000000000000100001101 false +0b0000000000000000000000000000000000000000000000000000001000000000 true 0b0000000000000000000000000000000000000000000000000000001000001101 false +0b0000000000000000000000000000000000000000000000000000010000000000 true 0b0000000000000000000000000000000000000000000000000000010000001101 false +0b0000000000000000000000000000000000000000000000000000100000000000 true 0b0000000000000000000000000000000000000000000000000000100000001101 false +0b0000000000000000000000000000000000000000000000000001000000000000 true 0b0000000000000000000000000000000000000000000000000001000000001101 false +0b0000000000000000000000000000000000000000000000000010000000000000 true 0b0000000000000000000000000000000000000000000000000010000000001101 false +0b0000000000000000000000000000000000000000000000000100000000000000 true 0b0000000000000000000000000000000000000000000000000100000000001101 false +0b0000000000000000000000000000000000000000000000001000000000000000 true 0b0000000000000000000000000000000000000000000000001000000000001101 false +0b0000000000000000000000000000000000000000000000010000000000000000 true 0b0000000000000000000000000000000000000000000000010000000000001101 false +0b0000000000000000000000000000000000000000000000100000000000000000 true 0b0000000000000000000000000000000000000000000000100000000000001101 false +0b0000000000000000000000000000000000000000000001000000000000000000 true 0b0000000000000000000000000000000000000000000001000000000000001101 false +0b0000000000000000000000000000000000000000000010000000000000000000 true 0b0000000000000000000000000000000000000000000010000000000000001101 false +0b0000000000000000000000000000000000000000000100000000000000000000 true 0b0000000000000000000000000000000000000000000100000000000000001101 false +0b0000000000000000000000000000000000000000001000000000000000000000 true 0b0000000000000000000000000000000000000000001000000000000000001101 false +0b0000000000000000000000000000000000000000010000000000000000000000 true 0b0000000000000000000000000000000000000000010000000000000000001101 false +0b0000000000000000000000000000000000000000100000000000000000000000 true 0b0000000000000000000000000000000000000000100000000000000000001101 false +0b0000000000000000000000000000000000000001000000000000000000000000 true 0b0000000000000000000000000000000000000001000000000000000000001101 false +0b0000000000000000000000000000000000000010000000000000000000000000 true 0b0000000000000000000000000000000000000010000000000000000000001101 false +0b0000000000000000000000000000000000000100000000000000000000000000 true 0b0000000000000000000000000000000000000100000000000000000000001101 false +0b0000000000000000000000000000000000001000000000000000000000000000 true 0b0000000000000000000000000000000000001000000000000000000000001101 false +0b0000000000000000000000000000000000010000000000000000000000000000 true 0b0000000000000000000000000000000000010000000000000000000000001101 false +0b0000000000000000000000000000000000100000000000000000000000000000 true 0b0000000000000000000000000000000000100000000000000000000000001101 false +0b0000000000000000000000000000000001000000000000000000000000000000 true 0b0000000000000000000000000000000001000000000000000000000000001101 false +0b0000000000000000000000000000000010000000000000000000000000000000 true 0b0000000000000000000000000000000010000000000000000000000000001101 false +0b0000000000000000000000000000000100000000000000000000000000000000 true 0b0000000000000000000000000000000100000000000000000000000000001101 false +0b0000000000000000000000000000001000000000000000000000000000000000 true 0b0000000000000000000000000000001000000000000000000000000000001101 false +0b0000000000000000000000000000010000000000000000000000000000000000 true 0b0000000000000000000000000000010000000000000000000000000000001101 false +0b0000000000000000000000000000100000000000000000000000000000000000 true 0b0000000000000000000000000000100000000000000000000000000000001101 false +0b0000000000000000000000000001000000000000000000000000000000000000 true 0b0000000000000000000000000001000000000000000000000000000000001101 false +0b0000000000000000000000000010000000000000000000000000000000000000 true 0b0000000000000000000000000010000000000000000000000000000000001101 false +0b0000000000000000000000000100000000000000000000000000000000000000 true 0b0000000000000000000000000100000000000000000000000000000000001101 false +0b0000000000000000000000001000000000000000000000000000000000000000 true 0b0000000000000000000000001000000000000000000000000000000000001101 false +0b0000000000000000000000010000000000000000000000000000000000000000 true 0b0000000000000000000000010000000000000000000000000000000000001101 false +0b0000000000000000000000100000000000000000000000000000000000000000 true 0b0000000000000000000000100000000000000000000000000000000000001101 false +0b0000000000000000000001000000000000000000000000000000000000000000 true 0b0000000000000000000001000000000000000000000000000000000000001101 false +0b0000000000000000000010000000000000000000000000000000000000000000 true 0b0000000000000000000010000000000000000000000000000000000000001101 false +0b0000000000000000000100000000000000000000000000000000000000000000 true 0b0000000000000000000100000000000000000000000000000000000000001101 false +0b0000000000000000001000000000000000000000000000000000000000000000 true 0b0000000000000000001000000000000000000000000000000000000000001101 false +0b0000000000000000010000000000000000000000000000000000000000000000 true 0b0000000000000000010000000000000000000000000000000000000000001101 false +0b0000000000000000100000000000000000000000000000000000000000000000 true 0b0000000000000000100000000000000000000000000000000000000000001101 false +0b0000000000000001000000000000000000000000000000000000000000000000 true 0b0000000000000001000000000000000000000000000000000000000000001101 false +0b0000000000000010000000000000000000000000000000000000000000000000 true 0b0000000000000010000000000000000000000000000000000000000000001101 false +0b0000000000000100000000000000000000000000000000000000000000000000 true 0b0000000000000100000000000000000000000000000000000000000000001101 false +0b0000000000001000000000000000000000000000000000000000000000000000 true 0b0000000000001000000000000000000000000000000000000000000000001101 false +0b0000000000010000000000000000000000000000000000000000000000000000 true 0b0000000000010000000000000000000000000000000000000000000000001101 false +0b0000000000100000000000000000000000000000000000000000000000000000 true 0b0000000000100000000000000000000000000000000000000000000000001101 false +0b0000000001000000000000000000000000000000000000000000000000000000 true 0b0000000001000000000000000000000000000000000000000000000000001101 false +0b0000000010000000000000000000000000000000000000000000000000000000 true 0b0000000010000000000000000000000000000000000000000000000000001101 false +0b0000000100000000000000000000000000000000000000000000000000000000 true 0b0000000100000000000000000000000000000000000000000000000000001101 false +0b0000001000000000000000000000000000000000000000000000000000000000 true 0b0000001000000000000000000000000000000000000000000000000000001101 false +0b0000010000000000000000000000000000000000000000000000000000000000 true 0b0000010000000000000000000000000000000000000000000000000000001101 false +0b0000100000000000000000000000000000000000000000000000000000000000 true 0b0000100000000000000000000000000000000000000000000000000000001101 false +0b0001000000000000000000000000000000000000000000000000000000000000 true 0b0001000000000000000000000000000000000000000000000000000000001101 false +0b0010000000000000000000000000000000000000000000000000000000000000 true 0b0010000000000000000000000000000000000000000000000000000000001101 false +0b0100000000000000000000000000000000000000000000000000000000000000 true 0b0100000000000000000000000000000000000000000000000000000000001101 false +0b1000000000000000000000000000000000000000000000000000000000000000 true 0b1000000000000000000000000000000000000000000000000000000000001101 false + + +floor2 + +signed char +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(-128, -128) = -128, floor2(-126, -128) = -128, floor2(126, -128) = 0 + +unsigned char +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(254, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(253, 1) = 253 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(252, 2) = 252 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(250, 4) = 248 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(246, 8) = 240 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(238, 16) = 224 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(222, 32) = 192 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(190, 64) = 128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(126, 128) = 0 + +short int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(-130, 128) = -256 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(-258, 256) = -512 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(-514, 512) = -1024 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(-1026, 1024) = -2048 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(-2050, 2048) = -4096 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(-4098, 4096) = -8192 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(-8194, 8192) = -16384 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(-16386, 16384) = -32768 +floor2(-32768, -32768) = -32768, floor2(-32766, -32768) = -32768, floor2(32766, -32768) = 0 + +unsigned short int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(65534, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(65533, 1) = 65533 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(65532, 2) = 65532 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(65530, 4) = 65528 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(65526, 8) = 65520 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(65518, 16) = 65504 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(65502, 32) = 65472 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(65470, 64) = 65408 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(65406, 128) = 65280 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(65278, 256) = 65024 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(65022, 512) = 64512 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(64510, 1024) = 63488 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(63486, 2048) = 61440 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(61438, 4096) = 57344 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(57342, 8192) = 49152 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(49150, 16384) = 32768 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(32766, 32768) = 0 + +int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(-130, 128) = -256 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(-258, 256) = -512 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(-514, 512) = -1024 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(-1026, 1024) = -2048 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(-2050, 2048) = -4096 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(-4098, 4096) = -8192 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(-8194, 8192) = -16384 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(-16386, 16384) = -32768 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(-32770, 32768) = -65536 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(-65538, 65536) = -131072 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(-131074, 131072) = -262144 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(-262146, 262144) = -524288 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(-524290, 524288) = -1048576 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(-1048578, 1048576) = -2097152 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(-2097154, 2097152) = -4194304 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(-4194306, 4194304) = -8388608 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(-8388610, 8388608) = -16777216 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(-16777218, 16777216) = -33554432 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(-33554434, 33554432) = -67108864 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(-67108866, 67108864) = -134217728 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(-134217730, 134217728) = -268435456 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(-268435458, 268435456) = -536870912 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(-536870914, 536870912) = -1073741824 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(-1073741826, 1073741824) = -2147483648 +floor2(-2147483648, -2147483648) = -2147483648, floor2(-2147483646, -2147483648) = -2147483648, floor2(2147483646, -2147483648) = 0 + +unsigned int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(4294967294, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(4294967293, 1) = 4294967293 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(4294967292, 2) = 4294967292 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(4294967290, 4) = 4294967288 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(4294967286, 8) = 4294967280 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(4294967278, 16) = 4294967264 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(4294967262, 32) = 4294967232 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(4294967230, 64) = 4294967168 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(4294967166, 128) = 4294967040 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(4294967038, 256) = 4294966784 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(4294966782, 512) = 4294966272 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(4294966270, 1024) = 4294965248 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(4294965246, 2048) = 4294963200 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(4294963198, 4096) = 4294959104 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(4294959102, 8192) = 4294950912 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(4294950910, 16384) = 4294934528 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(4294934526, 32768) = 4294901760 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(4294901758, 65536) = 4294836224 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(4294836222, 131072) = 4294705152 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(4294705150, 262144) = 4294443008 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(4294443006, 524288) = 4293918720 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(4293918718, 1048576) = 4292870144 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(4292870142, 2097152) = 4290772992 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(4290772990, 4194304) = 4286578688 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(4286578686, 8388608) = 4278190080 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(4278190078, 16777216) = 4261412864 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(4261412862, 33554432) = 4227858432 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(4227858430, 67108864) = 4160749568 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(4160749566, 134217728) = 4026531840 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(4026531838, 268435456) = 3758096384 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(3758096382, 536870912) = 3221225472 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(3221225470, 1073741824) = 2147483648 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(2147483646, 2147483648) = 0 + +long int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(-130, 128) = -256 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(-258, 256) = -512 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(-514, 512) = -1024 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(-1026, 1024) = -2048 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(-2050, 2048) = -4096 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(-4098, 4096) = -8192 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(-8194, 8192) = -16384 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(-16386, 16384) = -32768 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(-32770, 32768) = -65536 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(-65538, 65536) = -131072 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(-131074, 131072) = -262144 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(-262146, 262144) = -524288 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(-524290, 524288) = -1048576 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(-1048578, 1048576) = -2097152 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(-2097154, 2097152) = -4194304 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(-4194306, 4194304) = -8388608 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(-8388610, 8388608) = -16777216 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(-16777218, 16777216) = -33554432 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(-33554434, 33554432) = -67108864 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(-67108866, 67108864) = -134217728 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(-134217730, 134217728) = -268435456 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(-268435458, 268435456) = -536870912 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(-536870914, 536870912) = -1073741824 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(-1073741826, 1073741824) = -2147483648 +floor2(-2147483648, -2147483648) = -2147483648, floor2(-2147483646, -2147483648) = -2147483648, floor2(2147483646, -2147483648) = 0 + +unsigned long int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(4294967294, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(4294967293, 1) = 4294967293 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(4294967292, 2) = 4294967292 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(4294967290, 4) = 4294967288 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(4294967286, 8) = 4294967280 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(4294967278, 16) = 4294967264 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(4294967262, 32) = 4294967232 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(4294967230, 64) = 4294967168 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(4294967166, 128) = 4294967040 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(4294967038, 256) = 4294966784 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(4294966782, 512) = 4294966272 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(4294966270, 1024) = 4294965248 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(4294965246, 2048) = 4294963200 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(4294963198, 4096) = 4294959104 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(4294959102, 8192) = 4294950912 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(4294950910, 16384) = 4294934528 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(4294934526, 32768) = 4294901760 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(4294901758, 65536) = 4294836224 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(4294836222, 131072) = 4294705152 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(4294705150, 262144) = 4294443008 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(4294443006, 524288) = 4293918720 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(4293918718, 1048576) = 4292870144 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(4292870142, 2097152) = 4290772992 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(4290772990, 4194304) = 4286578688 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(4286578686, 8388608) = 4278190080 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(4278190078, 16777216) = 4261412864 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(4261412862, 33554432) = 4227858432 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(4227858430, 67108864) = 4160749568 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(4160749566, 134217728) = 4026531840 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(4026531838, 268435456) = 3758096384 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(3758096382, 536870912) = 3221225472 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(3221225470, 1073741824) = 2147483648 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(2147483646, 2147483648) = 0 + +long long int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(-2, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(-3, 1) = -3 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(-4, 2) = -4 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(-6, 4) = -8 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(-10, 8) = -16 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(-18, 16) = -32 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(-34, 32) = -64 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(-66, 64) = -128 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(-130, 128) = -256 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(-258, 256) = -512 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(-514, 512) = -1024 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(-1026, 1024) = -2048 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(-2050, 2048) = -4096 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(-4098, 4096) = -8192 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(-8194, 8192) = -16384 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(-16386, 16384) = -32768 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(-32770, 32768) = -65536 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(-65538, 65536) = -131072 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(-131074, 131072) = -262144 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(-262146, 262144) = -524288 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(-524290, 524288) = -1048576 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(-1048578, 1048576) = -2097152 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(-2097154, 2097152) = -4194304 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(-4194306, 4194304) = -8388608 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(-8388610, 8388608) = -16777216 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(-16777218, 16777216) = -33554432 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(-33554434, 33554432) = -67108864 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(-67108866, 67108864) = -134217728 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(-134217730, 134217728) = -268435456 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(-268435458, 268435456) = -536870912 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(-536870914, 536870912) = -1073741824 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(-1073741826, 1073741824) = -2147483648 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(-2147483650, 2147483648) = -4294967296 +floor2(4294967296, 4294967296) = 4294967296, floor2(4294967298, 4294967296) = 4294967296, floor2(-4294967298, 4294967296) = -8589934592 +floor2(8589934592, 8589934592) = 8589934592, floor2(8589934594, 8589934592) = 8589934592, floor2(-8589934594, 8589934592) = -17179869184 +floor2(17179869184, 17179869184) = 17179869184, floor2(17179869186, 17179869184) = 17179869184, floor2(-17179869186, 17179869184) = -34359738368 +floor2(34359738368, 34359738368) = 34359738368, floor2(34359738370, 34359738368) = 34359738368, floor2(-34359738370, 34359738368) = -68719476736 +floor2(68719476736, 68719476736) = 68719476736, floor2(68719476738, 68719476736) = 68719476736, floor2(-68719476738, 68719476736) = -137438953472 +floor2(137438953472, 137438953472) = 137438953472, floor2(137438953474, 137438953472) = 137438953472, floor2(-137438953474, 137438953472) = -274877906944 +floor2(274877906944, 274877906944) = 274877906944, floor2(274877906946, 274877906944) = 274877906944, floor2(-274877906946, 274877906944) = -549755813888 +floor2(549755813888, 549755813888) = 549755813888, floor2(549755813890, 549755813888) = 549755813888, floor2(-549755813890, 549755813888) = -1099511627776 +floor2(1099511627776, 1099511627776) = 1099511627776, floor2(1099511627778, 1099511627776) = 1099511627776, floor2(-1099511627778, 1099511627776) = -2199023255552 +floor2(2199023255552, 2199023255552) = 2199023255552, floor2(2199023255554, 2199023255552) = 2199023255552, floor2(-2199023255554, 2199023255552) = -4398046511104 +floor2(4398046511104, 4398046511104) = 4398046511104, floor2(4398046511106, 4398046511104) = 4398046511104, floor2(-4398046511106, 4398046511104) = -8796093022208 +floor2(8796093022208, 8796093022208) = 8796093022208, floor2(8796093022210, 8796093022208) = 8796093022208, floor2(-8796093022210, 8796093022208) = -17592186044416 +floor2(17592186044416, 17592186044416) = 17592186044416, floor2(17592186044418, 17592186044416) = 17592186044416, floor2(-17592186044418, 17592186044416) = -35184372088832 +floor2(35184372088832, 35184372088832) = 35184372088832, floor2(35184372088834, 35184372088832) = 35184372088832, floor2(-35184372088834, 35184372088832) = -70368744177664 +floor2(70368744177664, 70368744177664) = 70368744177664, floor2(70368744177666, 70368744177664) = 70368744177664, floor2(-70368744177666, 70368744177664) = -140737488355328 +floor2(140737488355328, 140737488355328) = 140737488355328, floor2(140737488355330, 140737488355328) = 140737488355328, floor2(-140737488355330, 140737488355328) = -281474976710656 +floor2(281474976710656, 281474976710656) = 281474976710656, floor2(281474976710658, 281474976710656) = 281474976710656, floor2(-281474976710658, 281474976710656) = -562949953421312 +floor2(562949953421312, 562949953421312) = 562949953421312, floor2(562949953421314, 562949953421312) = 562949953421312, floor2(-562949953421314, 562949953421312) = -1125899906842624 +floor2(1125899906842624, 1125899906842624) = 1125899906842624, floor2(1125899906842626, 1125899906842624) = 1125899906842624, floor2(-1125899906842626, 1125899906842624) = -2251799813685248 +floor2(2251799813685248, 2251799813685248) = 2251799813685248, floor2(2251799813685250, 2251799813685248) = 2251799813685248, floor2(-2251799813685250, 2251799813685248) = -4503599627370496 +floor2(4503599627370496, 4503599627370496) = 4503599627370496, floor2(4503599627370498, 4503599627370496) = 4503599627370496, floor2(-4503599627370498, 4503599627370496) = -9007199254740992 +floor2(9007199254740992, 9007199254740992) = 9007199254740992, floor2(9007199254740994, 9007199254740992) = 9007199254740992, floor2(-9007199254740994, 9007199254740992) = -18014398509481984 +floor2(18014398509481984, 18014398509481984) = 18014398509481984, floor2(18014398509481986, 18014398509481984) = 18014398509481984, floor2(-18014398509481986, 18014398509481984) = -36028797018963968 +floor2(36028797018963968, 36028797018963968) = 36028797018963968, floor2(36028797018963970, 36028797018963968) = 36028797018963968, floor2(-36028797018963970, 36028797018963968) = -72057594037927936 +floor2(72057594037927936, 72057594037927936) = 72057594037927936, floor2(72057594037927938, 72057594037927936) = 72057594037927936, floor2(-72057594037927938, 72057594037927936) = -144115188075855872 +floor2(144115188075855872, 144115188075855872) = 144115188075855872, floor2(144115188075855874, 144115188075855872) = 144115188075855872, floor2(-144115188075855874, 144115188075855872) = -288230376151711744 +floor2(288230376151711744, 288230376151711744) = 288230376151711744, floor2(288230376151711746, 288230376151711744) = 288230376151711744, floor2(-288230376151711746, 288230376151711744) = -576460752303423488 +floor2(576460752303423488, 576460752303423488) = 576460752303423488, floor2(576460752303423490, 576460752303423488) = 576460752303423488, floor2(-576460752303423490, 576460752303423488) = -1152921504606846976 +floor2(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor2(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor2(-1152921504606846978, 1152921504606846976) = -2305843009213693952 +floor2(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor2(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor2(-2305843009213693954, 2305843009213693952) = -4611686018427387904 +floor2(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor2(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor2(-4611686018427387906, 4611686018427387904) = -9223372036854775808 +floor2(-9223372036854775808, -9223372036854775808) = -9223372036854775808, floor2(-9223372036854775806, -9223372036854775808) = -9223372036854775808, floor2(9223372036854775806, -9223372036854775808) = 0 + +unsigned long long int +floor2(0, 0) = 0, floor2(2, 0) = 0, floor2(18446744073709551614, 0) = 0 +floor2(1, 1) = 1, floor2(3, 1) = 3, floor2(18446744073709551613, 1) = 18446744073709551613 +floor2(2, 2) = 2, floor2(4, 2) = 4, floor2(18446744073709551612, 2) = 18446744073709551612 +floor2(4, 4) = 4, floor2(6, 4) = 4, floor2(18446744073709551610, 4) = 18446744073709551608 +floor2(8, 8) = 8, floor2(10, 8) = 8, floor2(18446744073709551606, 8) = 18446744073709551600 +floor2(16, 16) = 16, floor2(18, 16) = 16, floor2(18446744073709551598, 16) = 18446744073709551584 +floor2(32, 32) = 32, floor2(34, 32) = 32, floor2(18446744073709551582, 32) = 18446744073709551552 +floor2(64, 64) = 64, floor2(66, 64) = 64, floor2(18446744073709551550, 64) = 18446744073709551488 +floor2(128, 128) = 128, floor2(130, 128) = 128, floor2(18446744073709551486, 128) = 18446744073709551360 +floor2(256, 256) = 256, floor2(258, 256) = 256, floor2(18446744073709551358, 256) = 18446744073709551104 +floor2(512, 512) = 512, floor2(514, 512) = 512, floor2(18446744073709551102, 512) = 18446744073709550592 +floor2(1024, 1024) = 1024, floor2(1026, 1024) = 1024, floor2(18446744073709550590, 1024) = 18446744073709549568 +floor2(2048, 2048) = 2048, floor2(2050, 2048) = 2048, floor2(18446744073709549566, 2048) = 18446744073709547520 +floor2(4096, 4096) = 4096, floor2(4098, 4096) = 4096, floor2(18446744073709547518, 4096) = 18446744073709543424 +floor2(8192, 8192) = 8192, floor2(8194, 8192) = 8192, floor2(18446744073709543422, 8192) = 18446744073709535232 +floor2(16384, 16384) = 16384, floor2(16386, 16384) = 16384, floor2(18446744073709535230, 16384) = 18446744073709518848 +floor2(32768, 32768) = 32768, floor2(32770, 32768) = 32768, floor2(18446744073709518846, 32768) = 18446744073709486080 +floor2(65536, 65536) = 65536, floor2(65538, 65536) = 65536, floor2(18446744073709486078, 65536) = 18446744073709420544 +floor2(131072, 131072) = 131072, floor2(131074, 131072) = 131072, floor2(18446744073709420542, 131072) = 18446744073709289472 +floor2(262144, 262144) = 262144, floor2(262146, 262144) = 262144, floor2(18446744073709289470, 262144) = 18446744073709027328 +floor2(524288, 524288) = 524288, floor2(524290, 524288) = 524288, floor2(18446744073709027326, 524288) = 18446744073708503040 +floor2(1048576, 1048576) = 1048576, floor2(1048578, 1048576) = 1048576, floor2(18446744073708503038, 1048576) = 18446744073707454464 +floor2(2097152, 2097152) = 2097152, floor2(2097154, 2097152) = 2097152, floor2(18446744073707454462, 2097152) = 18446744073705357312 +floor2(4194304, 4194304) = 4194304, floor2(4194306, 4194304) = 4194304, floor2(18446744073705357310, 4194304) = 18446744073701163008 +floor2(8388608, 8388608) = 8388608, floor2(8388610, 8388608) = 8388608, floor2(18446744073701163006, 8388608) = 18446744073692774400 +floor2(16777216, 16777216) = 16777216, floor2(16777218, 16777216) = 16777216, floor2(18446744073692774398, 16777216) = 18446744073675997184 +floor2(33554432, 33554432) = 33554432, floor2(33554434, 33554432) = 33554432, floor2(18446744073675997182, 33554432) = 18446744073642442752 +floor2(67108864, 67108864) = 67108864, floor2(67108866, 67108864) = 67108864, floor2(18446744073642442750, 67108864) = 18446744073575333888 +floor2(134217728, 134217728) = 134217728, floor2(134217730, 134217728) = 134217728, floor2(18446744073575333886, 134217728) = 18446744073441116160 +floor2(268435456, 268435456) = 268435456, floor2(268435458, 268435456) = 268435456, floor2(18446744073441116158, 268435456) = 18446744073172680704 +floor2(536870912, 536870912) = 536870912, floor2(536870914, 536870912) = 536870912, floor2(18446744073172680702, 536870912) = 18446744072635809792 +floor2(1073741824, 1073741824) = 1073741824, floor2(1073741826, 1073741824) = 1073741824, floor2(18446744072635809790, 1073741824) = 18446744071562067968 +floor2(2147483648, 2147483648) = 2147483648, floor2(2147483650, 2147483648) = 2147483648, floor2(18446744071562067966, 2147483648) = 18446744069414584320 +floor2(4294967296, 4294967296) = 4294967296, floor2(4294967298, 4294967296) = 4294967296, floor2(18446744069414584318, 4294967296) = 18446744065119617024 +floor2(8589934592, 8589934592) = 8589934592, floor2(8589934594, 8589934592) = 8589934592, floor2(18446744065119617022, 8589934592) = 18446744056529682432 +floor2(17179869184, 17179869184) = 17179869184, floor2(17179869186, 17179869184) = 17179869184, floor2(18446744056529682430, 17179869184) = 18446744039349813248 +floor2(34359738368, 34359738368) = 34359738368, floor2(34359738370, 34359738368) = 34359738368, floor2(18446744039349813246, 34359738368) = 18446744004990074880 +floor2(68719476736, 68719476736) = 68719476736, floor2(68719476738, 68719476736) = 68719476736, floor2(18446744004990074878, 68719476736) = 18446743936270598144 +floor2(137438953472, 137438953472) = 137438953472, floor2(137438953474, 137438953472) = 137438953472, floor2(18446743936270598142, 137438953472) = 18446743798831644672 +floor2(274877906944, 274877906944) = 274877906944, floor2(274877906946, 274877906944) = 274877906944, floor2(18446743798831644670, 274877906944) = 18446743523953737728 +floor2(549755813888, 549755813888) = 549755813888, floor2(549755813890, 549755813888) = 549755813888, floor2(18446743523953737726, 549755813888) = 18446742974197923840 +floor2(1099511627776, 1099511627776) = 1099511627776, floor2(1099511627778, 1099511627776) = 1099511627776, floor2(18446742974197923838, 1099511627776) = 18446741874686296064 +floor2(2199023255552, 2199023255552) = 2199023255552, floor2(2199023255554, 2199023255552) = 2199023255552, floor2(18446741874686296062, 2199023255552) = 18446739675663040512 +floor2(4398046511104, 4398046511104) = 4398046511104, floor2(4398046511106, 4398046511104) = 4398046511104, floor2(18446739675663040510, 4398046511104) = 18446735277616529408 +floor2(8796093022208, 8796093022208) = 8796093022208, floor2(8796093022210, 8796093022208) = 8796093022208, floor2(18446735277616529406, 8796093022208) = 18446726481523507200 +floor2(17592186044416, 17592186044416) = 17592186044416, floor2(17592186044418, 17592186044416) = 17592186044416, floor2(18446726481523507198, 17592186044416) = 18446708889337462784 +floor2(35184372088832, 35184372088832) = 35184372088832, floor2(35184372088834, 35184372088832) = 35184372088832, floor2(18446708889337462782, 35184372088832) = 18446673704965373952 +floor2(70368744177664, 70368744177664) = 70368744177664, floor2(70368744177666, 70368744177664) = 70368744177664, floor2(18446673704965373950, 70368744177664) = 18446603336221196288 +floor2(140737488355328, 140737488355328) = 140737488355328, floor2(140737488355330, 140737488355328) = 140737488355328, floor2(18446603336221196286, 140737488355328) = 18446462598732840960 +floor2(281474976710656, 281474976710656) = 281474976710656, floor2(281474976710658, 281474976710656) = 281474976710656, floor2(18446462598732840958, 281474976710656) = 18446181123756130304 +floor2(562949953421312, 562949953421312) = 562949953421312, floor2(562949953421314, 562949953421312) = 562949953421312, floor2(18446181123756130302, 562949953421312) = 18445618173802708992 +floor2(1125899906842624, 1125899906842624) = 1125899906842624, floor2(1125899906842626, 1125899906842624) = 1125899906842624, floor2(18445618173802708990, 1125899906842624) = 18444492273895866368 +floor2(2251799813685248, 2251799813685248) = 2251799813685248, floor2(2251799813685250, 2251799813685248) = 2251799813685248, floor2(18444492273895866366, 2251799813685248) = 18442240474082181120 +floor2(4503599627370496, 4503599627370496) = 4503599627370496, floor2(4503599627370498, 4503599627370496) = 4503599627370496, floor2(18442240474082181118, 4503599627370496) = 18437736874454810624 +floor2(9007199254740992, 9007199254740992) = 9007199254740992, floor2(9007199254740994, 9007199254740992) = 9007199254740992, floor2(18437736874454810622, 9007199254740992) = 18428729675200069632 +floor2(18014398509481984, 18014398509481984) = 18014398509481984, floor2(18014398509481986, 18014398509481984) = 18014398509481984, floor2(18428729675200069630, 18014398509481984) = 18410715276690587648 +floor2(36028797018963968, 36028797018963968) = 36028797018963968, floor2(36028797018963970, 36028797018963968) = 36028797018963968, floor2(18410715276690587646, 36028797018963968) = 18374686479671623680 +floor2(72057594037927936, 72057594037927936) = 72057594037927936, floor2(72057594037927938, 72057594037927936) = 72057594037927936, floor2(18374686479671623678, 72057594037927936) = 18302628885633695744 +floor2(144115188075855872, 144115188075855872) = 144115188075855872, floor2(144115188075855874, 144115188075855872) = 144115188075855872, floor2(18302628885633695742, 144115188075855872) = 18158513697557839872 +floor2(288230376151711744, 288230376151711744) = 288230376151711744, floor2(288230376151711746, 288230376151711744) = 288230376151711744, floor2(18158513697557839870, 288230376151711744) = 17870283321406128128 +floor2(576460752303423488, 576460752303423488) = 576460752303423488, floor2(576460752303423490, 576460752303423488) = 576460752303423488, floor2(17870283321406128126, 576460752303423488) = 17293822569102704640 +floor2(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor2(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor2(17293822569102704638, 1152921504606846976) = 16140901064495857664 +floor2(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor2(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor2(16140901064495857662, 2305843009213693952) = 13835058055282163712 +floor2(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor2(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor2(13835058055282163710, 4611686018427387904) = 9223372036854775808 +floor2(9223372036854775808, 9223372036854775808) = 9223372036854775808, floor2(9223372036854775810, 9223372036854775808) = 9223372036854775808, floor2(9223372036854775806, 9223372036854775808) = 0 + + +floor + +signed char +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(-128, -128) = -128, floor(-126, -128) = 0, floor(126, -128) = 0 + +unsigned char +floor(1, 1) = 1, floor(3, 1) = 3, floor(253, 1) = 253 +floor(2, 2) = 2, floor(4, 2) = 4, floor(252, 2) = 252 +floor(4, 4) = 4, floor(6, 4) = 4, floor(250, 4) = 248 +floor(8, 8) = 8, floor(10, 8) = 8, floor(246, 8) = 240 +floor(16, 16) = 16, floor(18, 16) = 16, floor(238, 16) = 224 +floor(32, 32) = 32, floor(34, 32) = 32, floor(222, 32) = 192 +floor(64, 64) = 64, floor(66, 64) = 64, floor(190, 64) = 128 +floor(128, 128) = 128, floor(130, 128) = 128, floor(126, 128) = 0 + +short int +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(128, 128) = 128, floor(130, 128) = 128, floor(-130, 128) = -128 +floor(256, 256) = 256, floor(258, 256) = 256, floor(-258, 256) = -256 +floor(512, 512) = 512, floor(514, 512) = 512, floor(-514, 512) = -512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(-1026, 1024) = -1024 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(-2050, 2048) = -2048 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(-4098, 4096) = -4096 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(-8194, 8192) = -8192 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(-16386, 16384) = -16384 +floor(-32768, -32768) = -32768, floor(-32766, -32768) = 0, floor(32766, -32768) = 0 + +unsigned short int +floor(1, 1) = 1, floor(3, 1) = 3, floor(65533, 1) = 65533 +floor(2, 2) = 2, floor(4, 2) = 4, floor(65532, 2) = 65532 +floor(4, 4) = 4, floor(6, 4) = 4, floor(65530, 4) = 65528 +floor(8, 8) = 8, floor(10, 8) = 8, floor(65526, 8) = 65520 +floor(16, 16) = 16, floor(18, 16) = 16, floor(65518, 16) = 65504 +floor(32, 32) = 32, floor(34, 32) = 32, floor(65502, 32) = 65472 +floor(64, 64) = 64, floor(66, 64) = 64, floor(65470, 64) = 65408 +floor(128, 128) = 128, floor(130, 128) = 128, floor(65406, 128) = 65280 +floor(256, 256) = 256, floor(258, 256) = 256, floor(65278, 256) = 65024 +floor(512, 512) = 512, floor(514, 512) = 512, floor(65022, 512) = 64512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(64510, 1024) = 63488 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(63486, 2048) = 61440 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(61438, 4096) = 57344 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(57342, 8192) = 49152 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(49150, 16384) = 32768 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(32766, 32768) = 0 + +int +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(128, 128) = 128, floor(130, 128) = 128, floor(-130, 128) = -128 +floor(256, 256) = 256, floor(258, 256) = 256, floor(-258, 256) = -256 +floor(512, 512) = 512, floor(514, 512) = 512, floor(-514, 512) = -512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(-1026, 1024) = -1024 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(-2050, 2048) = -2048 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(-4098, 4096) = -4096 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(-8194, 8192) = -8192 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(-16386, 16384) = -16384 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(-32770, 32768) = -32768 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(-65538, 65536) = -65536 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(-131074, 131072) = -131072 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(-262146, 262144) = -262144 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(-524290, 524288) = -524288 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(-1048578, 1048576) = -1048576 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(-2097154, 2097152) = -2097152 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(-4194306, 4194304) = -4194304 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(-8388610, 8388608) = -8388608 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(-16777218, 16777216) = -16777216 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(-33554434, 33554432) = -33554432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(-67108866, 67108864) = -67108864 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(-134217730, 134217728) = -134217728 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(-268435458, 268435456) = -268435456 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(-536870914, 536870912) = -536870912 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(-1073741826, 1073741824) = -1073741824 +floor(-2147483648, -2147483648) = -2147483648, floor(-2147483646, -2147483648) = 0, floor(2147483646, -2147483648) = 0 + +unsigned int +floor(1, 1) = 1, floor(3, 1) = 3, floor(4294967293, 1) = 4294967293 +floor(2, 2) = 2, floor(4, 2) = 4, floor(4294967292, 2) = 4294967292 +floor(4, 4) = 4, floor(6, 4) = 4, floor(4294967290, 4) = 4294967288 +floor(8, 8) = 8, floor(10, 8) = 8, floor(4294967286, 8) = 4294967280 +floor(16, 16) = 16, floor(18, 16) = 16, floor(4294967278, 16) = 4294967264 +floor(32, 32) = 32, floor(34, 32) = 32, floor(4294967262, 32) = 4294967232 +floor(64, 64) = 64, floor(66, 64) = 64, floor(4294967230, 64) = 4294967168 +floor(128, 128) = 128, floor(130, 128) = 128, floor(4294967166, 128) = 4294967040 +floor(256, 256) = 256, floor(258, 256) = 256, floor(4294967038, 256) = 4294966784 +floor(512, 512) = 512, floor(514, 512) = 512, floor(4294966782, 512) = 4294966272 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(4294966270, 1024) = 4294965248 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(4294965246, 2048) = 4294963200 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(4294963198, 4096) = 4294959104 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(4294959102, 8192) = 4294950912 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(4294950910, 16384) = 4294934528 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(4294934526, 32768) = 4294901760 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(4294901758, 65536) = 4294836224 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(4294836222, 131072) = 4294705152 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(4294705150, 262144) = 4294443008 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(4294443006, 524288) = 4293918720 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(4293918718, 1048576) = 4292870144 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(4292870142, 2097152) = 4290772992 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(4290772990, 4194304) = 4286578688 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(4286578686, 8388608) = 4278190080 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(4278190078, 16777216) = 4261412864 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(4261412862, 33554432) = 4227858432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(4227858430, 67108864) = 4160749568 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(4160749566, 134217728) = 4026531840 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(4026531838, 268435456) = 3758096384 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(3758096382, 536870912) = 3221225472 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(3221225470, 1073741824) = 2147483648 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(2147483646, 2147483648) = 0 + +long int +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(128, 128) = 128, floor(130, 128) = 128, floor(-130, 128) = -128 +floor(256, 256) = 256, floor(258, 256) = 256, floor(-258, 256) = -256 +floor(512, 512) = 512, floor(514, 512) = 512, floor(-514, 512) = -512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(-1026, 1024) = -1024 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(-2050, 2048) = -2048 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(-4098, 4096) = -4096 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(-8194, 8192) = -8192 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(-16386, 16384) = -16384 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(-32770, 32768) = -32768 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(-65538, 65536) = -65536 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(-131074, 131072) = -131072 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(-262146, 262144) = -262144 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(-524290, 524288) = -524288 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(-1048578, 1048576) = -1048576 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(-2097154, 2097152) = -2097152 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(-4194306, 4194304) = -4194304 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(-8388610, 8388608) = -8388608 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(-16777218, 16777216) = -16777216 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(-33554434, 33554432) = -33554432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(-67108866, 67108864) = -67108864 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(-134217730, 134217728) = -134217728 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(-268435458, 268435456) = -268435456 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(-536870914, 536870912) = -536870912 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(-1073741826, 1073741824) = -1073741824 +floor(-2147483648, -2147483648) = -2147483648, floor(-2147483646, -2147483648) = 0, floor(2147483646, -2147483648) = 0 + +unsigned long int +floor(1, 1) = 1, floor(3, 1) = 3, floor(4294967293, 1) = 4294967293 +floor(2, 2) = 2, floor(4, 2) = 4, floor(4294967292, 2) = 4294967292 +floor(4, 4) = 4, floor(6, 4) = 4, floor(4294967290, 4) = 4294967288 +floor(8, 8) = 8, floor(10, 8) = 8, floor(4294967286, 8) = 4294967280 +floor(16, 16) = 16, floor(18, 16) = 16, floor(4294967278, 16) = 4294967264 +floor(32, 32) = 32, floor(34, 32) = 32, floor(4294967262, 32) = 4294967232 +floor(64, 64) = 64, floor(66, 64) = 64, floor(4294967230, 64) = 4294967168 +floor(128, 128) = 128, floor(130, 128) = 128, floor(4294967166, 128) = 4294967040 +floor(256, 256) = 256, floor(258, 256) = 256, floor(4294967038, 256) = 4294966784 +floor(512, 512) = 512, floor(514, 512) = 512, floor(4294966782, 512) = 4294966272 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(4294966270, 1024) = 4294965248 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(4294965246, 2048) = 4294963200 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(4294963198, 4096) = 4294959104 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(4294959102, 8192) = 4294950912 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(4294950910, 16384) = 4294934528 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(4294934526, 32768) = 4294901760 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(4294901758, 65536) = 4294836224 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(4294836222, 131072) = 4294705152 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(4294705150, 262144) = 4294443008 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(4294443006, 524288) = 4293918720 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(4293918718, 1048576) = 4292870144 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(4292870142, 2097152) = 4290772992 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(4290772990, 4194304) = 4286578688 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(4286578686, 8388608) = 4278190080 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(4278190078, 16777216) = 4261412864 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(4261412862, 33554432) = 4227858432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(4227858430, 67108864) = 4160749568 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(4160749566, 134217728) = 4026531840 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(4026531838, 268435456) = 3758096384 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(3758096382, 536870912) = 3221225472 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(3221225470, 1073741824) = 2147483648 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(2147483646, 2147483648) = 0 + +long long int +floor(1, 1) = 1, floor(3, 1) = 3, floor(-3, 1) = -3 +floor(2, 2) = 2, floor(4, 2) = 4, floor(-4, 2) = -4 +floor(4, 4) = 4, floor(6, 4) = 4, floor(-6, 4) = -4 +floor(8, 8) = 8, floor(10, 8) = 8, floor(-10, 8) = -8 +floor(16, 16) = 16, floor(18, 16) = 16, floor(-18, 16) = -16 +floor(32, 32) = 32, floor(34, 32) = 32, floor(-34, 32) = -32 +floor(64, 64) = 64, floor(66, 64) = 64, floor(-66, 64) = -64 +floor(128, 128) = 128, floor(130, 128) = 128, floor(-130, 128) = -128 +floor(256, 256) = 256, floor(258, 256) = 256, floor(-258, 256) = -256 +floor(512, 512) = 512, floor(514, 512) = 512, floor(-514, 512) = -512 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(-1026, 1024) = -1024 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(-2050, 2048) = -2048 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(-4098, 4096) = -4096 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(-8194, 8192) = -8192 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(-16386, 16384) = -16384 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(-32770, 32768) = -32768 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(-65538, 65536) = -65536 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(-131074, 131072) = -131072 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(-262146, 262144) = -262144 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(-524290, 524288) = -524288 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(-1048578, 1048576) = -1048576 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(-2097154, 2097152) = -2097152 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(-4194306, 4194304) = -4194304 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(-8388610, 8388608) = -8388608 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(-16777218, 16777216) = -16777216 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(-33554434, 33554432) = -33554432 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(-67108866, 67108864) = -67108864 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(-134217730, 134217728) = -134217728 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(-268435458, 268435456) = -268435456 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(-536870914, 536870912) = -536870912 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(-1073741826, 1073741824) = -1073741824 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(-2147483650, 2147483648) = -2147483648 +floor(4294967296, 4294967296) = 4294967296, floor(4294967298, 4294967296) = 4294967296, floor(-4294967298, 4294967296) = -4294967296 +floor(8589934592, 8589934592) = 8589934592, floor(8589934594, 8589934592) = 8589934592, floor(-8589934594, 8589934592) = -8589934592 +floor(17179869184, 17179869184) = 17179869184, floor(17179869186, 17179869184) = 17179869184, floor(-17179869186, 17179869184) = -17179869184 +floor(34359738368, 34359738368) = 34359738368, floor(34359738370, 34359738368) = 34359738368, floor(-34359738370, 34359738368) = -34359738368 +floor(68719476736, 68719476736) = 68719476736, floor(68719476738, 68719476736) = 68719476736, floor(-68719476738, 68719476736) = -68719476736 +floor(137438953472, 137438953472) = 137438953472, floor(137438953474, 137438953472) = 137438953472, floor(-137438953474, 137438953472) = -137438953472 +floor(274877906944, 274877906944) = 274877906944, floor(274877906946, 274877906944) = 274877906944, floor(-274877906946, 274877906944) = -274877906944 +floor(549755813888, 549755813888) = 549755813888, floor(549755813890, 549755813888) = 549755813888, floor(-549755813890, 549755813888) = -549755813888 +floor(1099511627776, 1099511627776) = 1099511627776, floor(1099511627778, 1099511627776) = 1099511627776, floor(-1099511627778, 1099511627776) = -1099511627776 +floor(2199023255552, 2199023255552) = 2199023255552, floor(2199023255554, 2199023255552) = 2199023255552, floor(-2199023255554, 2199023255552) = -2199023255552 +floor(4398046511104, 4398046511104) = 4398046511104, floor(4398046511106, 4398046511104) = 4398046511104, floor(-4398046511106, 4398046511104) = -4398046511104 +floor(8796093022208, 8796093022208) = 8796093022208, floor(8796093022210, 8796093022208) = 8796093022208, floor(-8796093022210, 8796093022208) = -8796093022208 +floor(17592186044416, 17592186044416) = 17592186044416, floor(17592186044418, 17592186044416) = 17592186044416, floor(-17592186044418, 17592186044416) = -17592186044416 +floor(35184372088832, 35184372088832) = 35184372088832, floor(35184372088834, 35184372088832) = 35184372088832, floor(-35184372088834, 35184372088832) = -35184372088832 +floor(70368744177664, 70368744177664) = 70368744177664, floor(70368744177666, 70368744177664) = 70368744177664, floor(-70368744177666, 70368744177664) = -70368744177664 +floor(140737488355328, 140737488355328) = 140737488355328, floor(140737488355330, 140737488355328) = 140737488355328, floor(-140737488355330, 140737488355328) = -140737488355328 +floor(281474976710656, 281474976710656) = 281474976710656, floor(281474976710658, 281474976710656) = 281474976710656, floor(-281474976710658, 281474976710656) = -281474976710656 +floor(562949953421312, 562949953421312) = 562949953421312, floor(562949953421314, 562949953421312) = 562949953421312, floor(-562949953421314, 562949953421312) = -562949953421312 +floor(1125899906842624, 1125899906842624) = 1125899906842624, floor(1125899906842626, 1125899906842624) = 1125899906842624, floor(-1125899906842626, 1125899906842624) = -1125899906842624 +floor(2251799813685248, 2251799813685248) = 2251799813685248, floor(2251799813685250, 2251799813685248) = 2251799813685248, floor(-2251799813685250, 2251799813685248) = -2251799813685248 +floor(4503599627370496, 4503599627370496) = 4503599627370496, floor(4503599627370498, 4503599627370496) = 4503599627370496, floor(-4503599627370498, 4503599627370496) = -4503599627370496 +floor(9007199254740992, 9007199254740992) = 9007199254740992, floor(9007199254740994, 9007199254740992) = 9007199254740992, floor(-9007199254740994, 9007199254740992) = -9007199254740992 +floor(18014398509481984, 18014398509481984) = 18014398509481984, floor(18014398509481986, 18014398509481984) = 18014398509481984, floor(-18014398509481986, 18014398509481984) = -18014398509481984 +floor(36028797018963968, 36028797018963968) = 36028797018963968, floor(36028797018963970, 36028797018963968) = 36028797018963968, floor(-36028797018963970, 36028797018963968) = -36028797018963968 +floor(72057594037927936, 72057594037927936) = 72057594037927936, floor(72057594037927938, 72057594037927936) = 72057594037927936, floor(-72057594037927938, 72057594037927936) = -72057594037927936 +floor(144115188075855872, 144115188075855872) = 144115188075855872, floor(144115188075855874, 144115188075855872) = 144115188075855872, floor(-144115188075855874, 144115188075855872) = -144115188075855872 +floor(288230376151711744, 288230376151711744) = 288230376151711744, floor(288230376151711746, 288230376151711744) = 288230376151711744, floor(-288230376151711746, 288230376151711744) = -288230376151711744 +floor(576460752303423488, 576460752303423488) = 576460752303423488, floor(576460752303423490, 576460752303423488) = 576460752303423488, floor(-576460752303423490, 576460752303423488) = -576460752303423488 +floor(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor(-1152921504606846978, 1152921504606846976) = -1152921504606846976 +floor(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor(-2305843009213693954, 2305843009213693952) = -2305843009213693952 +floor(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor(-4611686018427387906, 4611686018427387904) = -4611686018427387904 +floor(-9223372036854775808, -9223372036854775808) = -9223372036854775808, floor(-9223372036854775806, -9223372036854775808) = 0, floor(9223372036854775806, -9223372036854775808) = 0 + +unsigned long long int +floor(1, 1) = 1, floor(3, 1) = 3, floor(18446744073709551613, 1) = 18446744073709551613 +floor(2, 2) = 2, floor(4, 2) = 4, floor(18446744073709551612, 2) = 18446744073709551612 +floor(4, 4) = 4, floor(6, 4) = 4, floor(18446744073709551610, 4) = 18446744073709551608 +floor(8, 8) = 8, floor(10, 8) = 8, floor(18446744073709551606, 8) = 18446744073709551600 +floor(16, 16) = 16, floor(18, 16) = 16, floor(18446744073709551598, 16) = 18446744073709551584 +floor(32, 32) = 32, floor(34, 32) = 32, floor(18446744073709551582, 32) = 18446744073709551552 +floor(64, 64) = 64, floor(66, 64) = 64, floor(18446744073709551550, 64) = 18446744073709551488 +floor(128, 128) = 128, floor(130, 128) = 128, floor(18446744073709551486, 128) = 18446744073709551360 +floor(256, 256) = 256, floor(258, 256) = 256, floor(18446744073709551358, 256) = 18446744073709551104 +floor(512, 512) = 512, floor(514, 512) = 512, floor(18446744073709551102, 512) = 18446744073709550592 +floor(1024, 1024) = 1024, floor(1026, 1024) = 1024, floor(18446744073709550590, 1024) = 18446744073709549568 +floor(2048, 2048) = 2048, floor(2050, 2048) = 2048, floor(18446744073709549566, 2048) = 18446744073709547520 +floor(4096, 4096) = 4096, floor(4098, 4096) = 4096, floor(18446744073709547518, 4096) = 18446744073709543424 +floor(8192, 8192) = 8192, floor(8194, 8192) = 8192, floor(18446744073709543422, 8192) = 18446744073709535232 +floor(16384, 16384) = 16384, floor(16386, 16384) = 16384, floor(18446744073709535230, 16384) = 18446744073709518848 +floor(32768, 32768) = 32768, floor(32770, 32768) = 32768, floor(18446744073709518846, 32768) = 18446744073709486080 +floor(65536, 65536) = 65536, floor(65538, 65536) = 65536, floor(18446744073709486078, 65536) = 18446744073709420544 +floor(131072, 131072) = 131072, floor(131074, 131072) = 131072, floor(18446744073709420542, 131072) = 18446744073709289472 +floor(262144, 262144) = 262144, floor(262146, 262144) = 262144, floor(18446744073709289470, 262144) = 18446744073709027328 +floor(524288, 524288) = 524288, floor(524290, 524288) = 524288, floor(18446744073709027326, 524288) = 18446744073708503040 +floor(1048576, 1048576) = 1048576, floor(1048578, 1048576) = 1048576, floor(18446744073708503038, 1048576) = 18446744073707454464 +floor(2097152, 2097152) = 2097152, floor(2097154, 2097152) = 2097152, floor(18446744073707454462, 2097152) = 18446744073705357312 +floor(4194304, 4194304) = 4194304, floor(4194306, 4194304) = 4194304, floor(18446744073705357310, 4194304) = 18446744073701163008 +floor(8388608, 8388608) = 8388608, floor(8388610, 8388608) = 8388608, floor(18446744073701163006, 8388608) = 18446744073692774400 +floor(16777216, 16777216) = 16777216, floor(16777218, 16777216) = 16777216, floor(18446744073692774398, 16777216) = 18446744073675997184 +floor(33554432, 33554432) = 33554432, floor(33554434, 33554432) = 33554432, floor(18446744073675997182, 33554432) = 18446744073642442752 +floor(67108864, 67108864) = 67108864, floor(67108866, 67108864) = 67108864, floor(18446744073642442750, 67108864) = 18446744073575333888 +floor(134217728, 134217728) = 134217728, floor(134217730, 134217728) = 134217728, floor(18446744073575333886, 134217728) = 18446744073441116160 +floor(268435456, 268435456) = 268435456, floor(268435458, 268435456) = 268435456, floor(18446744073441116158, 268435456) = 18446744073172680704 +floor(536870912, 536870912) = 536870912, floor(536870914, 536870912) = 536870912, floor(18446744073172680702, 536870912) = 18446744072635809792 +floor(1073741824, 1073741824) = 1073741824, floor(1073741826, 1073741824) = 1073741824, floor(18446744072635809790, 1073741824) = 18446744071562067968 +floor(2147483648, 2147483648) = 2147483648, floor(2147483650, 2147483648) = 2147483648, floor(18446744071562067966, 2147483648) = 18446744069414584320 +floor(4294967296, 4294967296) = 4294967296, floor(4294967298, 4294967296) = 4294967296, floor(18446744069414584318, 4294967296) = 18446744065119617024 +floor(8589934592, 8589934592) = 8589934592, floor(8589934594, 8589934592) = 8589934592, floor(18446744065119617022, 8589934592) = 18446744056529682432 +floor(17179869184, 17179869184) = 17179869184, floor(17179869186, 17179869184) = 17179869184, floor(18446744056529682430, 17179869184) = 18446744039349813248 +floor(34359738368, 34359738368) = 34359738368, floor(34359738370, 34359738368) = 34359738368, floor(18446744039349813246, 34359738368) = 18446744004990074880 +floor(68719476736, 68719476736) = 68719476736, floor(68719476738, 68719476736) = 68719476736, floor(18446744004990074878, 68719476736) = 18446743936270598144 +floor(137438953472, 137438953472) = 137438953472, floor(137438953474, 137438953472) = 137438953472, floor(18446743936270598142, 137438953472) = 18446743798831644672 +floor(274877906944, 274877906944) = 274877906944, floor(274877906946, 274877906944) = 274877906944, floor(18446743798831644670, 274877906944) = 18446743523953737728 +floor(549755813888, 549755813888) = 549755813888, floor(549755813890, 549755813888) = 549755813888, floor(18446743523953737726, 549755813888) = 18446742974197923840 +floor(1099511627776, 1099511627776) = 1099511627776, floor(1099511627778, 1099511627776) = 1099511627776, floor(18446742974197923838, 1099511627776) = 18446741874686296064 +floor(2199023255552, 2199023255552) = 2199023255552, floor(2199023255554, 2199023255552) = 2199023255552, floor(18446741874686296062, 2199023255552) = 18446739675663040512 +floor(4398046511104, 4398046511104) = 4398046511104, floor(4398046511106, 4398046511104) = 4398046511104, floor(18446739675663040510, 4398046511104) = 18446735277616529408 +floor(8796093022208, 8796093022208) = 8796093022208, floor(8796093022210, 8796093022208) = 8796093022208, floor(18446735277616529406, 8796093022208) = 18446726481523507200 +floor(17592186044416, 17592186044416) = 17592186044416, floor(17592186044418, 17592186044416) = 17592186044416, floor(18446726481523507198, 17592186044416) = 18446708889337462784 +floor(35184372088832, 35184372088832) = 35184372088832, floor(35184372088834, 35184372088832) = 35184372088832, floor(18446708889337462782, 35184372088832) = 18446673704965373952 +floor(70368744177664, 70368744177664) = 70368744177664, floor(70368744177666, 70368744177664) = 70368744177664, floor(18446673704965373950, 70368744177664) = 18446603336221196288 +floor(140737488355328, 140737488355328) = 140737488355328, floor(140737488355330, 140737488355328) = 140737488355328, floor(18446603336221196286, 140737488355328) = 18446462598732840960 +floor(281474976710656, 281474976710656) = 281474976710656, floor(281474976710658, 281474976710656) = 281474976710656, floor(18446462598732840958, 281474976710656) = 18446181123756130304 +floor(562949953421312, 562949953421312) = 562949953421312, floor(562949953421314, 562949953421312) = 562949953421312, floor(18446181123756130302, 562949953421312) = 18445618173802708992 +floor(1125899906842624, 1125899906842624) = 1125899906842624, floor(1125899906842626, 1125899906842624) = 1125899906842624, floor(18445618173802708990, 1125899906842624) = 18444492273895866368 +floor(2251799813685248, 2251799813685248) = 2251799813685248, floor(2251799813685250, 2251799813685248) = 2251799813685248, floor(18444492273895866366, 2251799813685248) = 18442240474082181120 +floor(4503599627370496, 4503599627370496) = 4503599627370496, floor(4503599627370498, 4503599627370496) = 4503599627370496, floor(18442240474082181118, 4503599627370496) = 18437736874454810624 +floor(9007199254740992, 9007199254740992) = 9007199254740992, floor(9007199254740994, 9007199254740992) = 9007199254740992, floor(18437736874454810622, 9007199254740992) = 18428729675200069632 +floor(18014398509481984, 18014398509481984) = 18014398509481984, floor(18014398509481986, 18014398509481984) = 18014398509481984, floor(18428729675200069630, 18014398509481984) = 18410715276690587648 +floor(36028797018963968, 36028797018963968) = 36028797018963968, floor(36028797018963970, 36028797018963968) = 36028797018963968, floor(18410715276690587646, 36028797018963968) = 18374686479671623680 +floor(72057594037927936, 72057594037927936) = 72057594037927936, floor(72057594037927938, 72057594037927936) = 72057594037927936, floor(18374686479671623678, 72057594037927936) = 18302628885633695744 +floor(144115188075855872, 144115188075855872) = 144115188075855872, floor(144115188075855874, 144115188075855872) = 144115188075855872, floor(18302628885633695742, 144115188075855872) = 18158513697557839872 +floor(288230376151711744, 288230376151711744) = 288230376151711744, floor(288230376151711746, 288230376151711744) = 288230376151711744, floor(18158513697557839870, 288230376151711744) = 17870283321406128128 +floor(576460752303423488, 576460752303423488) = 576460752303423488, floor(576460752303423490, 576460752303423488) = 576460752303423488, floor(17870283321406128126, 576460752303423488) = 17293822569102704640 +floor(1152921504606846976, 1152921504606846976) = 1152921504606846976, floor(1152921504606846978, 1152921504606846976) = 1152921504606846976, floor(17293822569102704638, 1152921504606846976) = 16140901064495857664 +floor(2305843009213693952, 2305843009213693952) = 2305843009213693952, floor(2305843009213693954, 2305843009213693952) = 2305843009213693952, floor(16140901064495857662, 2305843009213693952) = 13835058055282163712 +floor(4611686018427387904, 4611686018427387904) = 4611686018427387904, floor(4611686018427387906, 4611686018427387904) = 4611686018427387904, floor(13835058055282163710, 4611686018427387904) = 9223372036854775808 +floor(9223372036854775808, 9223372036854775808) = 9223372036854775808, floor(9223372036854775810, 9223372036854775808) = 9223372036854775808, floor(9223372036854775806, 9223372036854775808) = 0 + + +ceiling2 + +signed char +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = -128, ceiling2(-66, 64) = -64 +ceiling2(-128, -128) = -128, ceiling2(-126, -128) = 0, ceiling2(126, -128) = -128 + +unsigned char +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(254, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(253, 1) = 253 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(252, 2) = 252 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(250, 4) = 252 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(246, 8) = 248 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(238, 16) = 240 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(222, 32) = 224 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(190, 64) = 192 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 0, ceiling2(126, 128) = 128 + +short int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(-66, 64) = -64 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(-130, 128) = -128 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(-258, 256) = -256 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(-514, 512) = -512 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(-1026, 1024) = -1024 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(-2050, 2048) = -2048 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(-4098, 4096) = -4096 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(-8194, 8192) = -8192 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = -32768, ceiling2(-16386, 16384) = -16384 +ceiling2(-32768, -32768) = -32768, ceiling2(-32766, -32768) = 0, ceiling2(32766, -32768) = -32768 + +unsigned short int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(65534, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(65533, 1) = 65533 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(65532, 2) = 65532 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(65530, 4) = 65532 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(65526, 8) = 65528 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(65518, 16) = 65520 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(65502, 32) = 65504 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(65470, 64) = 65472 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(65406, 128) = 65408 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(65278, 256) = 65280 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(65022, 512) = 65024 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(64510, 1024) = 64512 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(63486, 2048) = 63488 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(61438, 4096) = 61440 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(57342, 8192) = 57344 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(49150, 16384) = 49152 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 0, ceiling2(32766, 32768) = 32768 + +int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(-66, 64) = -64 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(-130, 128) = -128 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(-258, 256) = -256 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(-514, 512) = -512 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(-1026, 1024) = -1024 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(-2050, 2048) = -2048 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(-4098, 4096) = -4096 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(-8194, 8192) = -8192 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(-16386, 16384) = -16384 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(-32770, 32768) = -32768 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(-65538, 65536) = -65536 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(-131074, 131072) = -131072 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(-262146, 262144) = -262144 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(-524290, 524288) = -524288 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(-1048578, 1048576) = -1048576 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(-2097154, 2097152) = -2097152 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(-4194306, 4194304) = -4194304 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(-8388610, 8388608) = -8388608 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(-16777218, 16777216) = -16777216 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(-33554434, 33554432) = -33554432 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(-67108866, 67108864) = -67108864 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(-134217730, 134217728) = -134217728 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(-268435458, 268435456) = -268435456 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(-536870914, 536870912) = -536870912 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = -2147483648, ceiling2(-1073741826, 1073741824) = -1073741824 +ceiling2(-2147483648, -2147483648) = -2147483648, ceiling2(-2147483646, -2147483648) = 0, ceiling2(2147483646, -2147483648) = -2147483648 + +unsigned int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(4294967294, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(4294967293, 1) = 4294967293 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(4294967292, 2) = 4294967292 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(4294967290, 4) = 4294967292 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(4294967286, 8) = 4294967288 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(4294967278, 16) = 4294967280 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(4294967262, 32) = 4294967264 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(4294967230, 64) = 4294967232 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(4294967166, 128) = 4294967168 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(4294967038, 256) = 4294967040 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(4294966782, 512) = 4294966784 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(4294966270, 1024) = 4294966272 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(4294965246, 2048) = 4294965248 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(4294963198, 4096) = 4294963200 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(4294959102, 8192) = 4294959104 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(4294950910, 16384) = 4294950912 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(4294934526, 32768) = 4294934528 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(4294901758, 65536) = 4294901760 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(4294836222, 131072) = 4294836224 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(4294705150, 262144) = 4294705152 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(4294443006, 524288) = 4294443008 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(4293918718, 1048576) = 4293918720 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(4292870142, 2097152) = 4292870144 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(4290772990, 4194304) = 4290772992 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(4286578686, 8388608) = 4286578688 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(4278190078, 16777216) = 4278190080 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(4261412862, 33554432) = 4261412864 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(4227858430, 67108864) = 4227858432 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(4160749566, 134217728) = 4160749568 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(4026531838, 268435456) = 4026531840 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(3758096382, 536870912) = 3758096384 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(3221225470, 1073741824) = 3221225472 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 0, ceiling2(2147483646, 2147483648) = 2147483648 + +long int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(-66, 64) = -64 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(-130, 128) = -128 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(-258, 256) = -256 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(-514, 512) = -512 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(-1026, 1024) = -1024 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(-2050, 2048) = -2048 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(-4098, 4096) = -4096 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(-8194, 8192) = -8192 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(-16386, 16384) = -16384 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(-32770, 32768) = -32768 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(-65538, 65536) = -65536 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(-131074, 131072) = -131072 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(-262146, 262144) = -262144 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(-524290, 524288) = -524288 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(-1048578, 1048576) = -1048576 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(-2097154, 2097152) = -2097152 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(-4194306, 4194304) = -4194304 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(-8388610, 8388608) = -8388608 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(-16777218, 16777216) = -16777216 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(-33554434, 33554432) = -33554432 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(-67108866, 67108864) = -67108864 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(-134217730, 134217728) = -134217728 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(-268435458, 268435456) = -268435456 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(-536870914, 536870912) = -536870912 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = -2147483648, ceiling2(-1073741826, 1073741824) = -1073741824 +ceiling2(-2147483648, -2147483648) = -2147483648, ceiling2(-2147483646, -2147483648) = 0, ceiling2(2147483646, -2147483648) = -2147483648 + +unsigned long int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(4294967294, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(4294967293, 1) = 4294967293 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(4294967292, 2) = 4294967292 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(4294967290, 4) = 4294967292 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(4294967286, 8) = 4294967288 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(4294967278, 16) = 4294967280 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(4294967262, 32) = 4294967264 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(4294967230, 64) = 4294967232 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(4294967166, 128) = 4294967168 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(4294967038, 256) = 4294967040 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(4294966782, 512) = 4294966784 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(4294966270, 1024) = 4294966272 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(4294965246, 2048) = 4294965248 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(4294963198, 4096) = 4294963200 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(4294959102, 8192) = 4294959104 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(4294950910, 16384) = 4294950912 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(4294934526, 32768) = 4294934528 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(4294901758, 65536) = 4294901760 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(4294836222, 131072) = 4294836224 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(4294705150, 262144) = 4294705152 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(4294443006, 524288) = 4294443008 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(4293918718, 1048576) = 4293918720 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(4292870142, 2097152) = 4292870144 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(4290772990, 4194304) = 4290772992 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(4286578686, 8388608) = 4286578688 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(4278190078, 16777216) = 4278190080 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(4261412862, 33554432) = 4261412864 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(4227858430, 67108864) = 4227858432 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(4160749566, 134217728) = 4160749568 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(4026531838, 268435456) = 4026531840 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(3758096382, 536870912) = 3758096384 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(3221225470, 1073741824) = 3221225472 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 0, ceiling2(2147483646, 2147483648) = 2147483648 + +long long int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(-2, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(-3, 1) = -3 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(-4, 2) = -4 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(-6, 4) = -4 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(-10, 8) = -8 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(-18, 16) = -16 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(-34, 32) = -32 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(-66, 64) = -64 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(-130, 128) = -128 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(-258, 256) = -256 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(-514, 512) = -512 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(-1026, 1024) = -1024 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(-2050, 2048) = -2048 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(-4098, 4096) = -4096 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(-8194, 8192) = -8192 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(-16386, 16384) = -16384 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(-32770, 32768) = -32768 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(-65538, 65536) = -65536 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(-131074, 131072) = -131072 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(-262146, 262144) = -262144 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(-524290, 524288) = -524288 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(-1048578, 1048576) = -1048576 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(-2097154, 2097152) = -2097152 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(-4194306, 4194304) = -4194304 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(-8388610, 8388608) = -8388608 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(-16777218, 16777216) = -16777216 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(-33554434, 33554432) = -33554432 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(-67108866, 67108864) = -67108864 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(-134217730, 134217728) = -134217728 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(-268435458, 268435456) = -268435456 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(-536870914, 536870912) = -536870912 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(-1073741826, 1073741824) = -1073741824 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 4294967296, ceiling2(-2147483650, 2147483648) = -2147483648 +ceiling2(4294967296, 4294967296) = 4294967296, ceiling2(4294967298, 4294967296) = 8589934592, ceiling2(-4294967298, 4294967296) = -4294967296 +ceiling2(8589934592, 8589934592) = 8589934592, ceiling2(8589934594, 8589934592) = 17179869184, ceiling2(-8589934594, 8589934592) = -8589934592 +ceiling2(17179869184, 17179869184) = 17179869184, ceiling2(17179869186, 17179869184) = 34359738368, ceiling2(-17179869186, 17179869184) = -17179869184 +ceiling2(34359738368, 34359738368) = 34359738368, ceiling2(34359738370, 34359738368) = 68719476736, ceiling2(-34359738370, 34359738368) = -34359738368 +ceiling2(68719476736, 68719476736) = 68719476736, ceiling2(68719476738, 68719476736) = 137438953472, ceiling2(-68719476738, 68719476736) = -68719476736 +ceiling2(137438953472, 137438953472) = 137438953472, ceiling2(137438953474, 137438953472) = 274877906944, ceiling2(-137438953474, 137438953472) = -137438953472 +ceiling2(274877906944, 274877906944) = 274877906944, ceiling2(274877906946, 274877906944) = 549755813888, ceiling2(-274877906946, 274877906944) = -274877906944 +ceiling2(549755813888, 549755813888) = 549755813888, ceiling2(549755813890, 549755813888) = 1099511627776, ceiling2(-549755813890, 549755813888) = -549755813888 +ceiling2(1099511627776, 1099511627776) = 1099511627776, ceiling2(1099511627778, 1099511627776) = 2199023255552, ceiling2(-1099511627778, 1099511627776) = -1099511627776 +ceiling2(2199023255552, 2199023255552) = 2199023255552, ceiling2(2199023255554, 2199023255552) = 4398046511104, ceiling2(-2199023255554, 2199023255552) = -2199023255552 +ceiling2(4398046511104, 4398046511104) = 4398046511104, ceiling2(4398046511106, 4398046511104) = 8796093022208, ceiling2(-4398046511106, 4398046511104) = -4398046511104 +ceiling2(8796093022208, 8796093022208) = 8796093022208, ceiling2(8796093022210, 8796093022208) = 17592186044416, ceiling2(-8796093022210, 8796093022208) = -8796093022208 +ceiling2(17592186044416, 17592186044416) = 17592186044416, ceiling2(17592186044418, 17592186044416) = 35184372088832, ceiling2(-17592186044418, 17592186044416) = -17592186044416 +ceiling2(35184372088832, 35184372088832) = 35184372088832, ceiling2(35184372088834, 35184372088832) = 70368744177664, ceiling2(-35184372088834, 35184372088832) = -35184372088832 +ceiling2(70368744177664, 70368744177664) = 70368744177664, ceiling2(70368744177666, 70368744177664) = 140737488355328, ceiling2(-70368744177666, 70368744177664) = -70368744177664 +ceiling2(140737488355328, 140737488355328) = 140737488355328, ceiling2(140737488355330, 140737488355328) = 281474976710656, ceiling2(-140737488355330, 140737488355328) = -140737488355328 +ceiling2(281474976710656, 281474976710656) = 281474976710656, ceiling2(281474976710658, 281474976710656) = 562949953421312, ceiling2(-281474976710658, 281474976710656) = -281474976710656 +ceiling2(562949953421312, 562949953421312) = 562949953421312, ceiling2(562949953421314, 562949953421312) = 1125899906842624, ceiling2(-562949953421314, 562949953421312) = -562949953421312 +ceiling2(1125899906842624, 1125899906842624) = 1125899906842624, ceiling2(1125899906842626, 1125899906842624) = 2251799813685248, ceiling2(-1125899906842626, 1125899906842624) = -1125899906842624 +ceiling2(2251799813685248, 2251799813685248) = 2251799813685248, ceiling2(2251799813685250, 2251799813685248) = 4503599627370496, ceiling2(-2251799813685250, 2251799813685248) = -2251799813685248 +ceiling2(4503599627370496, 4503599627370496) = 4503599627370496, ceiling2(4503599627370498, 4503599627370496) = 9007199254740992, ceiling2(-4503599627370498, 4503599627370496) = -4503599627370496 +ceiling2(9007199254740992, 9007199254740992) = 9007199254740992, ceiling2(9007199254740994, 9007199254740992) = 18014398509481984, ceiling2(-9007199254740994, 9007199254740992) = -9007199254740992 +ceiling2(18014398509481984, 18014398509481984) = 18014398509481984, ceiling2(18014398509481986, 18014398509481984) = 36028797018963968, ceiling2(-18014398509481986, 18014398509481984) = -18014398509481984 +ceiling2(36028797018963968, 36028797018963968) = 36028797018963968, ceiling2(36028797018963970, 36028797018963968) = 72057594037927936, ceiling2(-36028797018963970, 36028797018963968) = -36028797018963968 +ceiling2(72057594037927936, 72057594037927936) = 72057594037927936, ceiling2(72057594037927938, 72057594037927936) = 144115188075855872, ceiling2(-72057594037927938, 72057594037927936) = -72057594037927936 +ceiling2(144115188075855872, 144115188075855872) = 144115188075855872, ceiling2(144115188075855874, 144115188075855872) = 288230376151711744, ceiling2(-144115188075855874, 144115188075855872) = -144115188075855872 +ceiling2(288230376151711744, 288230376151711744) = 288230376151711744, ceiling2(288230376151711746, 288230376151711744) = 576460752303423488, ceiling2(-288230376151711746, 288230376151711744) = -288230376151711744 +ceiling2(576460752303423488, 576460752303423488) = 576460752303423488, ceiling2(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling2(-576460752303423490, 576460752303423488) = -576460752303423488 +ceiling2(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling2(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling2(-1152921504606846978, 1152921504606846976) = -1152921504606846976 +ceiling2(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling2(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling2(-2305843009213693954, 2305843009213693952) = -2305843009213693952 +ceiling2(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling2(4611686018427387906, 4611686018427387904) = -9223372036854775808, ceiling2(-4611686018427387906, 4611686018427387904) = -4611686018427387904 +ceiling2(-9223372036854775808, -9223372036854775808) = -9223372036854775808, ceiling2(-9223372036854775806, -9223372036854775808) = 0, ceiling2(9223372036854775806, -9223372036854775808) = -9223372036854775808 + +unsigned long long int +ceiling2(0, 0) = 0, ceiling2(2, 0) = 0, ceiling2(18446744073709551614, 0) = 0 +ceiling2(1, 1) = 1, ceiling2(3, 1) = 3, ceiling2(18446744073709551613, 1) = 18446744073709551613 +ceiling2(2, 2) = 2, ceiling2(4, 2) = 4, ceiling2(18446744073709551612, 2) = 18446744073709551612 +ceiling2(4, 4) = 4, ceiling2(6, 4) = 8, ceiling2(18446744073709551610, 4) = 18446744073709551612 +ceiling2(8, 8) = 8, ceiling2(10, 8) = 16, ceiling2(18446744073709551606, 8) = 18446744073709551608 +ceiling2(16, 16) = 16, ceiling2(18, 16) = 32, ceiling2(18446744073709551598, 16) = 18446744073709551600 +ceiling2(32, 32) = 32, ceiling2(34, 32) = 64, ceiling2(18446744073709551582, 32) = 18446744073709551584 +ceiling2(64, 64) = 64, ceiling2(66, 64) = 128, ceiling2(18446744073709551550, 64) = 18446744073709551552 +ceiling2(128, 128) = 128, ceiling2(130, 128) = 256, ceiling2(18446744073709551486, 128) = 18446744073709551488 +ceiling2(256, 256) = 256, ceiling2(258, 256) = 512, ceiling2(18446744073709551358, 256) = 18446744073709551360 +ceiling2(512, 512) = 512, ceiling2(514, 512) = 1024, ceiling2(18446744073709551102, 512) = 18446744073709551104 +ceiling2(1024, 1024) = 1024, ceiling2(1026, 1024) = 2048, ceiling2(18446744073709550590, 1024) = 18446744073709550592 +ceiling2(2048, 2048) = 2048, ceiling2(2050, 2048) = 4096, ceiling2(18446744073709549566, 2048) = 18446744073709549568 +ceiling2(4096, 4096) = 4096, ceiling2(4098, 4096) = 8192, ceiling2(18446744073709547518, 4096) = 18446744073709547520 +ceiling2(8192, 8192) = 8192, ceiling2(8194, 8192) = 16384, ceiling2(18446744073709543422, 8192) = 18446744073709543424 +ceiling2(16384, 16384) = 16384, ceiling2(16386, 16384) = 32768, ceiling2(18446744073709535230, 16384) = 18446744073709535232 +ceiling2(32768, 32768) = 32768, ceiling2(32770, 32768) = 65536, ceiling2(18446744073709518846, 32768) = 18446744073709518848 +ceiling2(65536, 65536) = 65536, ceiling2(65538, 65536) = 131072, ceiling2(18446744073709486078, 65536) = 18446744073709486080 +ceiling2(131072, 131072) = 131072, ceiling2(131074, 131072) = 262144, ceiling2(18446744073709420542, 131072) = 18446744073709420544 +ceiling2(262144, 262144) = 262144, ceiling2(262146, 262144) = 524288, ceiling2(18446744073709289470, 262144) = 18446744073709289472 +ceiling2(524288, 524288) = 524288, ceiling2(524290, 524288) = 1048576, ceiling2(18446744073709027326, 524288) = 18446744073709027328 +ceiling2(1048576, 1048576) = 1048576, ceiling2(1048578, 1048576) = 2097152, ceiling2(18446744073708503038, 1048576) = 18446744073708503040 +ceiling2(2097152, 2097152) = 2097152, ceiling2(2097154, 2097152) = 4194304, ceiling2(18446744073707454462, 2097152) = 18446744073707454464 +ceiling2(4194304, 4194304) = 4194304, ceiling2(4194306, 4194304) = 8388608, ceiling2(18446744073705357310, 4194304) = 18446744073705357312 +ceiling2(8388608, 8388608) = 8388608, ceiling2(8388610, 8388608) = 16777216, ceiling2(18446744073701163006, 8388608) = 18446744073701163008 +ceiling2(16777216, 16777216) = 16777216, ceiling2(16777218, 16777216) = 33554432, ceiling2(18446744073692774398, 16777216) = 18446744073692774400 +ceiling2(33554432, 33554432) = 33554432, ceiling2(33554434, 33554432) = 67108864, ceiling2(18446744073675997182, 33554432) = 18446744073675997184 +ceiling2(67108864, 67108864) = 67108864, ceiling2(67108866, 67108864) = 134217728, ceiling2(18446744073642442750, 67108864) = 18446744073642442752 +ceiling2(134217728, 134217728) = 134217728, ceiling2(134217730, 134217728) = 268435456, ceiling2(18446744073575333886, 134217728) = 18446744073575333888 +ceiling2(268435456, 268435456) = 268435456, ceiling2(268435458, 268435456) = 536870912, ceiling2(18446744073441116158, 268435456) = 18446744073441116160 +ceiling2(536870912, 536870912) = 536870912, ceiling2(536870914, 536870912) = 1073741824, ceiling2(18446744073172680702, 536870912) = 18446744073172680704 +ceiling2(1073741824, 1073741824) = 1073741824, ceiling2(1073741826, 1073741824) = 2147483648, ceiling2(18446744072635809790, 1073741824) = 18446744072635809792 +ceiling2(2147483648, 2147483648) = 2147483648, ceiling2(2147483650, 2147483648) = 4294967296, ceiling2(18446744071562067966, 2147483648) = 18446744071562067968 +ceiling2(4294967296, 4294967296) = 4294967296, ceiling2(4294967298, 4294967296) = 8589934592, ceiling2(18446744069414584318, 4294967296) = 18446744069414584320 +ceiling2(8589934592, 8589934592) = 8589934592, ceiling2(8589934594, 8589934592) = 17179869184, ceiling2(18446744065119617022, 8589934592) = 18446744065119617024 +ceiling2(17179869184, 17179869184) = 17179869184, ceiling2(17179869186, 17179869184) = 34359738368, ceiling2(18446744056529682430, 17179869184) = 18446744056529682432 +ceiling2(34359738368, 34359738368) = 34359738368, ceiling2(34359738370, 34359738368) = 68719476736, ceiling2(18446744039349813246, 34359738368) = 18446744039349813248 +ceiling2(68719476736, 68719476736) = 68719476736, ceiling2(68719476738, 68719476736) = 137438953472, ceiling2(18446744004990074878, 68719476736) = 18446744004990074880 +ceiling2(137438953472, 137438953472) = 137438953472, ceiling2(137438953474, 137438953472) = 274877906944, ceiling2(18446743936270598142, 137438953472) = 18446743936270598144 +ceiling2(274877906944, 274877906944) = 274877906944, ceiling2(274877906946, 274877906944) = 549755813888, ceiling2(18446743798831644670, 274877906944) = 18446743798831644672 +ceiling2(549755813888, 549755813888) = 549755813888, ceiling2(549755813890, 549755813888) = 1099511627776, ceiling2(18446743523953737726, 549755813888) = 18446743523953737728 +ceiling2(1099511627776, 1099511627776) = 1099511627776, ceiling2(1099511627778, 1099511627776) = 2199023255552, ceiling2(18446742974197923838, 1099511627776) = 18446742974197923840 +ceiling2(2199023255552, 2199023255552) = 2199023255552, ceiling2(2199023255554, 2199023255552) = 4398046511104, ceiling2(18446741874686296062, 2199023255552) = 18446741874686296064 +ceiling2(4398046511104, 4398046511104) = 4398046511104, ceiling2(4398046511106, 4398046511104) = 8796093022208, ceiling2(18446739675663040510, 4398046511104) = 18446739675663040512 +ceiling2(8796093022208, 8796093022208) = 8796093022208, ceiling2(8796093022210, 8796093022208) = 17592186044416, ceiling2(18446735277616529406, 8796093022208) = 18446735277616529408 +ceiling2(17592186044416, 17592186044416) = 17592186044416, ceiling2(17592186044418, 17592186044416) = 35184372088832, ceiling2(18446726481523507198, 17592186044416) = 18446726481523507200 +ceiling2(35184372088832, 35184372088832) = 35184372088832, ceiling2(35184372088834, 35184372088832) = 70368744177664, ceiling2(18446708889337462782, 35184372088832) = 18446708889337462784 +ceiling2(70368744177664, 70368744177664) = 70368744177664, ceiling2(70368744177666, 70368744177664) = 140737488355328, ceiling2(18446673704965373950, 70368744177664) = 18446673704965373952 +ceiling2(140737488355328, 140737488355328) = 140737488355328, ceiling2(140737488355330, 140737488355328) = 281474976710656, ceiling2(18446603336221196286, 140737488355328) = 18446603336221196288 +ceiling2(281474976710656, 281474976710656) = 281474976710656, ceiling2(281474976710658, 281474976710656) = 562949953421312, ceiling2(18446462598732840958, 281474976710656) = 18446462598732840960 +ceiling2(562949953421312, 562949953421312) = 562949953421312, ceiling2(562949953421314, 562949953421312) = 1125899906842624, ceiling2(18446181123756130302, 562949953421312) = 18446181123756130304 +ceiling2(1125899906842624, 1125899906842624) = 1125899906842624, ceiling2(1125899906842626, 1125899906842624) = 2251799813685248, ceiling2(18445618173802708990, 1125899906842624) = 18445618173802708992 +ceiling2(2251799813685248, 2251799813685248) = 2251799813685248, ceiling2(2251799813685250, 2251799813685248) = 4503599627370496, ceiling2(18444492273895866366, 2251799813685248) = 18444492273895866368 +ceiling2(4503599627370496, 4503599627370496) = 4503599627370496, ceiling2(4503599627370498, 4503599627370496) = 9007199254740992, ceiling2(18442240474082181118, 4503599627370496) = 18442240474082181120 +ceiling2(9007199254740992, 9007199254740992) = 9007199254740992, ceiling2(9007199254740994, 9007199254740992) = 18014398509481984, ceiling2(18437736874454810622, 9007199254740992) = 18437736874454810624 +ceiling2(18014398509481984, 18014398509481984) = 18014398509481984, ceiling2(18014398509481986, 18014398509481984) = 36028797018963968, ceiling2(18428729675200069630, 18014398509481984) = 18428729675200069632 +ceiling2(36028797018963968, 36028797018963968) = 36028797018963968, ceiling2(36028797018963970, 36028797018963968) = 72057594037927936, ceiling2(18410715276690587646, 36028797018963968) = 18410715276690587648 +ceiling2(72057594037927936, 72057594037927936) = 72057594037927936, ceiling2(72057594037927938, 72057594037927936) = 144115188075855872, ceiling2(18374686479671623678, 72057594037927936) = 18374686479671623680 +ceiling2(144115188075855872, 144115188075855872) = 144115188075855872, ceiling2(144115188075855874, 144115188075855872) = 288230376151711744, ceiling2(18302628885633695742, 144115188075855872) = 18302628885633695744 +ceiling2(288230376151711744, 288230376151711744) = 288230376151711744, ceiling2(288230376151711746, 288230376151711744) = 576460752303423488, ceiling2(18158513697557839870, 288230376151711744) = 18158513697557839872 +ceiling2(576460752303423488, 576460752303423488) = 576460752303423488, ceiling2(576460752303423490, 576460752303423488) = 1152921504606846976, ceiling2(17870283321406128126, 576460752303423488) = 17870283321406128128 +ceiling2(1152921504606846976, 1152921504606846976) = 1152921504606846976, ceiling2(1152921504606846978, 1152921504606846976) = 2305843009213693952, ceiling2(17293822569102704638, 1152921504606846976) = 17293822569102704640 +ceiling2(2305843009213693952, 2305843009213693952) = 2305843009213693952, ceiling2(2305843009213693954, 2305843009213693952) = 4611686018427387904, ceiling2(16140901064495857662, 2305843009213693952) = 16140901064495857664 +ceiling2(4611686018427387904, 4611686018427387904) = 4611686018427387904, ceiling2(4611686018427387906, 4611686018427387904) = 9223372036854775808, ceiling2(13835058055282163710, 4611686018427387904) = 13835058055282163712 +ceiling2(9223372036854775808, 9223372036854775808) = 9223372036854775808, ceiling2(9223372036854775810, 9223372036854775808) = 0, ceiling2(9223372036854775806, 9223372036854775808) = 9223372036854775808 + + +ceiling + +signed char +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(-128, -128) = 2, ceiling(-126, -128) = 1, ceiling(126, -128) = 0 + +unsigned char +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(253, 1) = 253 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(252, 2) = 126 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(250, 4) = 63 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(246, 8) = 31 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(238, 16) = 15 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(222, 32) = 7 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(190, 64) = 3 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(126, 128) = 1 + +short int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(-130, 128) = 0 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(-258, 256) = 0 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(-514, 512) = 0 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(-1026, 1024) = 0 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(-2050, 2048) = 0 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(-4098, 4096) = 0 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(-8194, 8192) = 0 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(-16386, 16384) = 0 +ceiling(-32768, -32768) = 2, ceiling(-32766, -32768) = 1, ceiling(32766, -32768) = 0 + +unsigned short int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(65533, 1) = 65533 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(65532, 2) = 32766 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(65530, 4) = 16383 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(65526, 8) = 8191 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(65518, 16) = 4095 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(65502, 32) = 2047 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(65470, 64) = 1023 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(65406, 128) = 511 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(65278, 256) = 255 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(65022, 512) = 127 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(64510, 1024) = 63 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(63486, 2048) = 31 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(61438, 4096) = 15 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(57342, 8192) = 7 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(49150, 16384) = 3 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(32766, 32768) = 1 + +int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(-130, 128) = 0 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(-258, 256) = 0 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(-514, 512) = 0 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(-1026, 1024) = 0 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(-2050, 2048) = 0 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(-4098, 4096) = 0 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(-8194, 8192) = 0 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(-16386, 16384) = 0 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(-32770, 32768) = 0 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(-65538, 65536) = 0 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(-131074, 131072) = 0 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(-262146, 262144) = 0 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(-524290, 524288) = 0 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(-1048578, 1048576) = 0 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(-2097154, 2097152) = 0 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(-4194306, 4194304) = 0 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(-8388610, 8388608) = 0 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(-16777218, 16777216) = 0 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(-33554434, 33554432) = 0 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(-67108866, 67108864) = 0 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(-134217730, 134217728) = 0 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(-268435458, 268435456) = 0 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(-536870914, 536870912) = 0 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = -1, ceiling(-1073741826, 1073741824) = 0 +ceiling(-2147483648, -2147483648) = 0, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = 0 + +unsigned int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(4294967293, 1) = 4294967293 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(4294967292, 2) = 2147483646 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(4294967290, 4) = 1073741823 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(4294967286, 8) = 536870911 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(4294967278, 16) = 268435455 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(4294967262, 32) = 134217727 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(4294967230, 64) = 67108863 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(4294967166, 128) = 33554431 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(4294967038, 256) = 16777215 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(4294966782, 512) = 8388607 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(4294966270, 1024) = 4194303 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(4294965246, 2048) = 2097151 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(4294963198, 4096) = 1048575 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(4294959102, 8192) = 524287 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(4294950910, 16384) = 262143 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(4294934526, 32768) = 131071 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(4294901758, 65536) = 65535 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(4294836222, 131072) = 32767 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(4294705150, 262144) = 16383 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(4294443006, 524288) = 8191 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(4293918718, 1048576) = 4095 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(4292870142, 2097152) = 2047 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(4290772990, 4194304) = 1023 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(4286578686, 8388608) = 511 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(4278190078, 16777216) = 255 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(4261412862, 33554432) = 127 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(4227858430, 67108864) = 63 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(4160749566, 134217728) = 31 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(4026531838, 268435456) = 15 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(3758096382, 536870912) = 7 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(3221225470, 1073741824) = 3 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 0, ceiling(2147483646, 2147483648) = 1 + +long int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(-130, 128) = 0 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(-258, 256) = 0 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(-514, 512) = 0 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(-1026, 1024) = 0 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(-2050, 2048) = 0 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(-4098, 4096) = 0 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(-8194, 8192) = 0 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(-16386, 16384) = 0 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(-32770, 32768) = 0 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(-65538, 65536) = 0 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(-131074, 131072) = 0 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(-262146, 262144) = 0 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(-524290, 524288) = 0 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(-1048578, 1048576) = 0 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(-2097154, 2097152) = 0 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(-4194306, 4194304) = 0 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(-8388610, 8388608) = 0 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(-16777218, 16777216) = 0 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(-33554434, 33554432) = 0 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(-67108866, 67108864) = 0 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(-134217730, 134217728) = 0 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(-268435458, 268435456) = 0 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(-536870914, 536870912) = 0 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = -1, ceiling(-1073741826, 1073741824) = 0 +ceiling(-2147483648, -2147483648) = 0, ceiling(-2147483646, -2147483648) = 0, ceiling(2147483646, -2147483648) = 0 + +unsigned long int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(4294967293, 1) = 4294967293 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(4294967292, 2) = 2147483646 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(4294967290, 4) = 1073741823 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(4294967286, 8) = 536870911 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(4294967278, 16) = 268435455 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(4294967262, 32) = 134217727 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(4294967230, 64) = 67108863 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(4294967166, 128) = 33554431 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(4294967038, 256) = 16777215 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(4294966782, 512) = 8388607 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(4294966270, 1024) = 4194303 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(4294965246, 2048) = 2097151 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(4294963198, 4096) = 1048575 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(4294959102, 8192) = 524287 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(4294950910, 16384) = 262143 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(4294934526, 32768) = 131071 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(4294901758, 65536) = 65535 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(4294836222, 131072) = 32767 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(4294705150, 262144) = 16383 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(4294443006, 524288) = 8191 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(4293918718, 1048576) = 4095 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(4292870142, 2097152) = 2047 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(4290772990, 4194304) = 1023 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(4286578686, 8388608) = 511 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(4278190078, 16777216) = 255 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(4261412862, 33554432) = 127 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(4227858430, 67108864) = 63 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(4160749566, 134217728) = 31 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(4026531838, 268435456) = 15 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(3758096382, 536870912) = 7 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(3221225470, 1073741824) = 3 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 0, ceiling(2147483646, 2147483648) = 1 + +long long int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(-3, 1) = -3 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(-4, 2) = -1 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(-6, 4) = 0 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(-10, 8) = 0 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(-18, 16) = 0 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(-34, 32) = 0 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(-66, 64) = 0 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(-130, 128) = 0 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(-258, 256) = 0 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(-514, 512) = 0 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(-1026, 1024) = 0 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(-2050, 2048) = 0 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(-4098, 4096) = 0 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(-8194, 8192) = 0 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(-16386, 16384) = 0 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(-32770, 32768) = 0 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(-65538, 65536) = 0 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(-131074, 131072) = 0 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(-262146, 262144) = 0 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(-524290, 524288) = 0 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(-1048578, 1048576) = 0 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(-2097154, 2097152) = 0 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(-4194306, 4194304) = 0 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(-8388610, 8388608) = 0 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(-16777218, 16777216) = 0 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(-33554434, 33554432) = 0 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(-67108866, 67108864) = 0 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(-134217730, 134217728) = 0 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(-268435458, 268435456) = 0 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(-536870914, 536870912) = 0 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(-1073741826, 1073741824) = 0 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 2, ceiling(-2147483650, 2147483648) = 0 +ceiling(4294967296, 4294967296) = 1, ceiling(4294967298, 4294967296) = 2, ceiling(-4294967298, 4294967296) = 0 +ceiling(8589934592, 8589934592) = 1, ceiling(8589934594, 8589934592) = 2, ceiling(-8589934594, 8589934592) = 0 +ceiling(17179869184, 17179869184) = 1, ceiling(17179869186, 17179869184) = 2, ceiling(-17179869186, 17179869184) = 0 +ceiling(34359738368, 34359738368) = 1, ceiling(34359738370, 34359738368) = 2, ceiling(-34359738370, 34359738368) = 0 +ceiling(68719476736, 68719476736) = 1, ceiling(68719476738, 68719476736) = 2, ceiling(-68719476738, 68719476736) = 0 +ceiling(137438953472, 137438953472) = 1, ceiling(137438953474, 137438953472) = 2, ceiling(-137438953474, 137438953472) = 0 +ceiling(274877906944, 274877906944) = 1, ceiling(274877906946, 274877906944) = 2, ceiling(-274877906946, 274877906944) = 0 +ceiling(549755813888, 549755813888) = 1, ceiling(549755813890, 549755813888) = 2, ceiling(-549755813890, 549755813888) = 0 +ceiling(1099511627776, 1099511627776) = 1, ceiling(1099511627778, 1099511627776) = 2, ceiling(-1099511627778, 1099511627776) = 0 +ceiling(2199023255552, 2199023255552) = 1, ceiling(2199023255554, 2199023255552) = 2, ceiling(-2199023255554, 2199023255552) = 0 +ceiling(4398046511104, 4398046511104) = 1, ceiling(4398046511106, 4398046511104) = 2, ceiling(-4398046511106, 4398046511104) = 0 +ceiling(8796093022208, 8796093022208) = 1, ceiling(8796093022210, 8796093022208) = 2, ceiling(-8796093022210, 8796093022208) = 0 +ceiling(17592186044416, 17592186044416) = 1, ceiling(17592186044418, 17592186044416) = 2, ceiling(-17592186044418, 17592186044416) = 0 +ceiling(35184372088832, 35184372088832) = 1, ceiling(35184372088834, 35184372088832) = 2, ceiling(-35184372088834, 35184372088832) = 0 +ceiling(70368744177664, 70368744177664) = 1, ceiling(70368744177666, 70368744177664) = 2, ceiling(-70368744177666, 70368744177664) = 0 +ceiling(140737488355328, 140737488355328) = 1, ceiling(140737488355330, 140737488355328) = 2, ceiling(-140737488355330, 140737488355328) = 0 +ceiling(281474976710656, 281474976710656) = 1, ceiling(281474976710658, 281474976710656) = 2, ceiling(-281474976710658, 281474976710656) = 0 +ceiling(562949953421312, 562949953421312) = 1, ceiling(562949953421314, 562949953421312) = 2, ceiling(-562949953421314, 562949953421312) = 0 +ceiling(1125899906842624, 1125899906842624) = 1, ceiling(1125899906842626, 1125899906842624) = 2, ceiling(-1125899906842626, 1125899906842624) = 0 +ceiling(2251799813685248, 2251799813685248) = 1, ceiling(2251799813685250, 2251799813685248) = 2, ceiling(-2251799813685250, 2251799813685248) = 0 +ceiling(4503599627370496, 4503599627370496) = 1, ceiling(4503599627370498, 4503599627370496) = 2, ceiling(-4503599627370498, 4503599627370496) = 0 +ceiling(9007199254740992, 9007199254740992) = 1, ceiling(9007199254740994, 9007199254740992) = 2, ceiling(-9007199254740994, 9007199254740992) = 0 +ceiling(18014398509481984, 18014398509481984) = 1, ceiling(18014398509481986, 18014398509481984) = 2, ceiling(-18014398509481986, 18014398509481984) = 0 +ceiling(36028797018963968, 36028797018963968) = 1, ceiling(36028797018963970, 36028797018963968) = 2, ceiling(-36028797018963970, 36028797018963968) = 0 +ceiling(72057594037927936, 72057594037927936) = 1, ceiling(72057594037927938, 72057594037927936) = 2, ceiling(-72057594037927938, 72057594037927936) = 0 +ceiling(144115188075855872, 144115188075855872) = 1, ceiling(144115188075855874, 144115188075855872) = 2, ceiling(-144115188075855874, 144115188075855872) = 0 +ceiling(288230376151711744, 288230376151711744) = 1, ceiling(288230376151711746, 288230376151711744) = 2, ceiling(-288230376151711746, 288230376151711744) = 0 +ceiling(576460752303423488, 576460752303423488) = 1, ceiling(576460752303423490, 576460752303423488) = 2, ceiling(-576460752303423490, 576460752303423488) = 0 +ceiling(1152921504606846976, 1152921504606846976) = 1, ceiling(1152921504606846978, 1152921504606846976) = 2, ceiling(-1152921504606846978, 1152921504606846976) = 0 +ceiling(2305843009213693952, 2305843009213693952) = 1, ceiling(2305843009213693954, 2305843009213693952) = 2, ceiling(-2305843009213693954, 2305843009213693952) = 0 +ceiling(4611686018427387904, 4611686018427387904) = 1, ceiling(4611686018427387906, 4611686018427387904) = -1, ceiling(-4611686018427387906, 4611686018427387904) = 0 +ceiling(-9223372036854775808, -9223372036854775808) = 0, ceiling(-9223372036854775806, -9223372036854775808) = 0, ceiling(9223372036854775806, -9223372036854775808) = 0 + +unsigned long long int +ceiling(1, 1) = 1, ceiling(3, 1) = 3, ceiling(18446744073709551613, 1) = 18446744073709551613 +ceiling(2, 2) = 1, ceiling(4, 2) = 2, ceiling(18446744073709551612, 2) = 9223372036854775806 +ceiling(4, 4) = 1, ceiling(6, 4) = 2, ceiling(18446744073709551610, 4) = 4611686018427387903 +ceiling(8, 8) = 1, ceiling(10, 8) = 2, ceiling(18446744073709551606, 8) = 2305843009213693951 +ceiling(16, 16) = 1, ceiling(18, 16) = 2, ceiling(18446744073709551598, 16) = 1152921504606846975 +ceiling(32, 32) = 1, ceiling(34, 32) = 2, ceiling(18446744073709551582, 32) = 576460752303423487 +ceiling(64, 64) = 1, ceiling(66, 64) = 2, ceiling(18446744073709551550, 64) = 288230376151711743 +ceiling(128, 128) = 1, ceiling(130, 128) = 2, ceiling(18446744073709551486, 128) = 144115188075855871 +ceiling(256, 256) = 1, ceiling(258, 256) = 2, ceiling(18446744073709551358, 256) = 72057594037927935 +ceiling(512, 512) = 1, ceiling(514, 512) = 2, ceiling(18446744073709551102, 512) = 36028797018963967 +ceiling(1024, 1024) = 1, ceiling(1026, 1024) = 2, ceiling(18446744073709550590, 1024) = 18014398509481983 +ceiling(2048, 2048) = 1, ceiling(2050, 2048) = 2, ceiling(18446744073709549566, 2048) = 9007199254740991 +ceiling(4096, 4096) = 1, ceiling(4098, 4096) = 2, ceiling(18446744073709547518, 4096) = 4503599627370495 +ceiling(8192, 8192) = 1, ceiling(8194, 8192) = 2, ceiling(18446744073709543422, 8192) = 2251799813685247 +ceiling(16384, 16384) = 1, ceiling(16386, 16384) = 2, ceiling(18446744073709535230, 16384) = 1125899906842623 +ceiling(32768, 32768) = 1, ceiling(32770, 32768) = 2, ceiling(18446744073709518846, 32768) = 562949953421311 +ceiling(65536, 65536) = 1, ceiling(65538, 65536) = 2, ceiling(18446744073709486078, 65536) = 281474976710655 +ceiling(131072, 131072) = 1, ceiling(131074, 131072) = 2, ceiling(18446744073709420542, 131072) = 140737488355327 +ceiling(262144, 262144) = 1, ceiling(262146, 262144) = 2, ceiling(18446744073709289470, 262144) = 70368744177663 +ceiling(524288, 524288) = 1, ceiling(524290, 524288) = 2, ceiling(18446744073709027326, 524288) = 35184372088831 +ceiling(1048576, 1048576) = 1, ceiling(1048578, 1048576) = 2, ceiling(18446744073708503038, 1048576) = 17592186044415 +ceiling(2097152, 2097152) = 1, ceiling(2097154, 2097152) = 2, ceiling(18446744073707454462, 2097152) = 8796093022207 +ceiling(4194304, 4194304) = 1, ceiling(4194306, 4194304) = 2, ceiling(18446744073705357310, 4194304) = 4398046511103 +ceiling(8388608, 8388608) = 1, ceiling(8388610, 8388608) = 2, ceiling(18446744073701163006, 8388608) = 2199023255551 +ceiling(16777216, 16777216) = 1, ceiling(16777218, 16777216) = 2, ceiling(18446744073692774398, 16777216) = 1099511627775 +ceiling(33554432, 33554432) = 1, ceiling(33554434, 33554432) = 2, ceiling(18446744073675997182, 33554432) = 549755813887 +ceiling(67108864, 67108864) = 1, ceiling(67108866, 67108864) = 2, ceiling(18446744073642442750, 67108864) = 274877906943 +ceiling(134217728, 134217728) = 1, ceiling(134217730, 134217728) = 2, ceiling(18446744073575333886, 134217728) = 137438953471 +ceiling(268435456, 268435456) = 1, ceiling(268435458, 268435456) = 2, ceiling(18446744073441116158, 268435456) = 68719476735 +ceiling(536870912, 536870912) = 1, ceiling(536870914, 536870912) = 2, ceiling(18446744073172680702, 536870912) = 34359738367 +ceiling(1073741824, 1073741824) = 1, ceiling(1073741826, 1073741824) = 2, ceiling(18446744072635809790, 1073741824) = 17179869183 +ceiling(2147483648, 2147483648) = 1, ceiling(2147483650, 2147483648) = 2, ceiling(18446744071562067966, 2147483648) = 8589934591 +ceiling(4294967296, 4294967296) = 1, ceiling(4294967298, 4294967296) = 2, ceiling(18446744069414584318, 4294967296) = 4294967295 +ceiling(8589934592, 8589934592) = 1, ceiling(8589934594, 8589934592) = 2, ceiling(18446744065119617022, 8589934592) = 2147483647 +ceiling(17179869184, 17179869184) = 1, ceiling(17179869186, 17179869184) = 2, ceiling(18446744056529682430, 17179869184) = 1073741823 +ceiling(34359738368, 34359738368) = 1, ceiling(34359738370, 34359738368) = 2, ceiling(18446744039349813246, 34359738368) = 536870911 +ceiling(68719476736, 68719476736) = 1, ceiling(68719476738, 68719476736) = 2, ceiling(18446744004990074878, 68719476736) = 268435455 +ceiling(137438953472, 137438953472) = 1, ceiling(137438953474, 137438953472) = 2, ceiling(18446743936270598142, 137438953472) = 134217727 +ceiling(274877906944, 274877906944) = 1, ceiling(274877906946, 274877906944) = 2, ceiling(18446743798831644670, 274877906944) = 67108863 +ceiling(549755813888, 549755813888) = 1, ceiling(549755813890, 549755813888) = 2, ceiling(18446743523953737726, 549755813888) = 33554431 +ceiling(1099511627776, 1099511627776) = 1, ceiling(1099511627778, 1099511627776) = 2, ceiling(18446742974197923838, 1099511627776) = 16777215 +ceiling(2199023255552, 2199023255552) = 1, ceiling(2199023255554, 2199023255552) = 2, ceiling(18446741874686296062, 2199023255552) = 8388607 +ceiling(4398046511104, 4398046511104) = 1, ceiling(4398046511106, 4398046511104) = 2, ceiling(18446739675663040510, 4398046511104) = 4194303 +ceiling(8796093022208, 8796093022208) = 1, ceiling(8796093022210, 8796093022208) = 2, ceiling(18446735277616529406, 8796093022208) = 2097151 +ceiling(17592186044416, 17592186044416) = 1, ceiling(17592186044418, 17592186044416) = 2, ceiling(18446726481523507198, 17592186044416) = 1048575 +ceiling(35184372088832, 35184372088832) = 1, ceiling(35184372088834, 35184372088832) = 2, ceiling(18446708889337462782, 35184372088832) = 524287 +ceiling(70368744177664, 70368744177664) = 1, ceiling(70368744177666, 70368744177664) = 2, ceiling(18446673704965373950, 70368744177664) = 262143 +ceiling(140737488355328, 140737488355328) = 1, ceiling(140737488355330, 140737488355328) = 2, ceiling(18446603336221196286, 140737488355328) = 131071 +ceiling(281474976710656, 281474976710656) = 1, ceiling(281474976710658, 281474976710656) = 2, ceiling(18446462598732840958, 281474976710656) = 65535 +ceiling(562949953421312, 562949953421312) = 1, ceiling(562949953421314, 562949953421312) = 2, ceiling(18446181123756130302, 562949953421312) = 32767 +ceiling(1125899906842624, 1125899906842624) = 1, ceiling(1125899906842626, 1125899906842624) = 2, ceiling(18445618173802708990, 1125899906842624) = 16383 +ceiling(2251799813685248, 2251799813685248) = 1, ceiling(2251799813685250, 2251799813685248) = 2, ceiling(18444492273895866366, 2251799813685248) = 8191 +ceiling(4503599627370496, 4503599627370496) = 1, ceiling(4503599627370498, 4503599627370496) = 2, ceiling(18442240474082181118, 4503599627370496) = 4095 +ceiling(9007199254740992, 9007199254740992) = 1, ceiling(9007199254740994, 9007199254740992) = 2, ceiling(18437736874454810622, 9007199254740992) = 2047 +ceiling(18014398509481984, 18014398509481984) = 1, ceiling(18014398509481986, 18014398509481984) = 2, ceiling(18428729675200069630, 18014398509481984) = 1023 +ceiling(36028797018963968, 36028797018963968) = 1, ceiling(36028797018963970, 36028797018963968) = 2, ceiling(18410715276690587646, 36028797018963968) = 511 +ceiling(72057594037927936, 72057594037927936) = 1, ceiling(72057594037927938, 72057594037927936) = 2, ceiling(18374686479671623678, 72057594037927936) = 255 +ceiling(144115188075855872, 144115188075855872) = 1, ceiling(144115188075855874, 144115188075855872) = 2, ceiling(18302628885633695742, 144115188075855872) = 127 +ceiling(288230376151711744, 288230376151711744) = 1, ceiling(288230376151711746, 288230376151711744) = 2, ceiling(18158513697557839870, 288230376151711744) = 63 +ceiling(576460752303423488, 576460752303423488) = 1, ceiling(576460752303423490, 576460752303423488) = 2, ceiling(17870283321406128126, 576460752303423488) = 31 +ceiling(1152921504606846976, 1152921504606846976) = 1, ceiling(1152921504606846978, 1152921504606846976) = 2, ceiling(17293822569102704638, 1152921504606846976) = 15 +ceiling(2305843009213693952, 2305843009213693952) = 1, ceiling(2305843009213693954, 2305843009213693952) = 2, ceiling(16140901064495857662, 2305843009213693952) = 7 +ceiling(4611686018427387904, 4611686018427387904) = 1, ceiling(4611686018427387906, 4611686018427387904) = 2, ceiling(13835058055282163710, 4611686018427387904) = 3 +ceiling(9223372036854775808, 9223372036854775808) = 1, ceiling(9223372036854775810, 9223372036854775808) = 0, ceiling(9223372036854775806, 9223372036854775808) = 1 + Index: tests/Makefile.am =================================================================== --- tests/Makefile.am (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/Makefile.am (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -41,4 +41,6 @@ -quiet @CFA_FLAGS@ \ -DIN_DIR="${abs_srcdir}/.in/" + +AM_CFAFLAGS = -XCFA --deterministic-out # get the desired cfa to test Index: tests/Makefile.in =================================================================== --- tests/Makefile.in (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/Makefile.in (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -408,4 +408,5 @@ -DIN_DIR="${abs_srcdir}/.in/" +AM_CFAFLAGS = -XCFA --deterministic-out # get the desired cfa to test Index: tests/alloc.cfa =================================================================== --- tests/alloc.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/alloc.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -10,6 +10,6 @@ // Created On : Wed Feb 3 07:56:22 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Apr 1 10:58:35 2020 -// Update Count : 424 +// Last Modified On : Mon Apr 6 21:08:23 2020 +// Update Count : 428 // @@ -151,11 +151,11 @@ ip = alloc_set( ip, 3 * dim, fill ); // CFA realloc array alloc, fill printf( "CFA realloc array alloc, fill\n" ); - for ( i; 3 * dim ) { printf( "%#x ", ip[i] );; } - printf( "\n" ); - // do not free - - ip = alloc_set( ip, 3 * dim, 5 ); // CFA realloc array alloc, 5 + for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); } + printf( "\n" ); + // do not free +#if 0 // FIX ME + ip = alloc_set( ip, 5 * dim, 5 ); // CFA realloc array alloc, 5 printf( "CFA realloc array alloc, 5\n" ); - for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); } + for ( i; 5 * dim ) { printf( "%#x ", ip[i] ); } printf( "\n" ); // do not free @@ -167,10 +167,10 @@ // do not free - ip = alloc_set( ip, 3 * dim, 5 ); // CFA realloc array alloc, 5 + ip = alloc_set( ip, 5 * dim, 5 ); // CFA realloc array alloc, 5 printf( "CFA realloc array alloc, 5\n" ); - for ( i; 3 * dim ) { printf( "%#x ", ip[i] );; } - printf( "\n" ); - free( ip ); - + for ( i; 5 * dim ) { printf( "%#x ", ip[i] ); } + printf( "\n" ); +#endif // 0 + free( ip ); // resize, non-array types Index: sts/bitmanip.cfa =================================================================== --- tests/bitmanip.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ (revision ) @@ -1,416 +1,0 @@ -#include -#include - -int main() { - signed char sc; - unsigned char usc; - short int si; - unsigned short int usi; - int i; - unsigned int ui; - long int li; - unsigned long int uli; - long long int lli; - unsigned long long int ulli; - - sout | nlOff; - - //============================================================ - - sout | "cl0" | nl; - - sc = 0; - sout | sc | cl0( sc ) | ","; - for ( sc = 1; sc != 0; sc <<= 1 ) { - sout | sc | cl0( sc ) | ","; - } // for - sout | nl; - usc = 0; - sout | usc | cl0( usc ) | ","; - for ( usc = 1; usc != 0; usc <<= 1 ) { - sout | usc | cl0( usc ) | ","; - } // for - sout | nl; - - si = 0; - sout | si | cl0( si ) | ","; - for ( si = 1; si != 0; si <<= 1 ) { - sout | si | cl0( si ) | ","; - } // for - sout | nl; - usi = 0; - sout | usi | cl0( usi ) | ","; - for ( usi = 1; usi != 0; usi <<= 1 ) { - sout | usi | cl0( usi ) | ","; - } // for - sout | nl; - - i = 0; - sout | i | cl0( i ) | ","; - for ( i = 1; i != 0; i <<= 1 ) { - sout | i | cl0( i ) | ","; - } // for - sout | nl; - ui = 0; - sout | ui | cl0( ui ) | ","; - for ( ui = 1; ui != 0; ui <<= 1 ) { - sout | ui | cl0( ui ) | ","; - } // for - sout | nl; - - li = 0; - sout | li | cl0( li ) | ","; - for ( li = 1; li != 0; li <<= 1 ) { - sout | li | cl0( li ) | ","; - } // for - sout | nl; - uli = 0; - sout | uli | cl0( uli ) | ","; - for ( uli = 1; uli != 0; uli <<= 1 ) { - sout | uli | cl0( uli ) | ","; - } // for - sout | nl; - - lli = 0; - sout | lli | cl0( lli ) | ","; - for ( lli = 1; lli != 0; lli <<= 1 ) { - sout | lli | cl0( lli ) | ","; - } // for - sout | nl; - ulli = 0; - sout | ulli | cl0( ulli ) | ","; - for ( ulli = 1; ulli != 0; ulli <<= 1 ) { - sout | ulli | cl0( ulli ) | ","; - } // for - sout | nl; - - //============================================================ - - sout | nl | "ct0" | nl; - - sc = 0; - sout | sc | ct0( sc ) | ","; - for ( sc = 1; sc != 0; sc <<= 1 ) { - sout | sc | ct0( sc ) | ","; - } // for - sout | nl; - usc = 0; - sout | usc | ct0( usc ) | ","; - for ( usc = 1; usc != 0; usc <<= 1 ) { - sout | usc | ct0( usc ) | ","; - } // for - sout | nl; - - si = 0; - sout | si | ct0( si ) | ","; - for ( si = 1; si != 0; si <<= 1 ) { - sout | si | ct0( si ) | ","; - } // for - sout | nl; - usi = 0; - sout | usi | ct0( usi ) | ","; - for ( usi = 1; usi != 0; usi <<= 1 ) { - sout | usi | ct0( usi ) | ","; - } // for - sout | nl; - - i = 0; - sout | i | ct0( i ) | ","; - for ( i = 1; i != 0; i <<= 1 ) { - sout | i | ct0( i ) | ","; - } // for - sout | nl; - ui = 0; - sout | ui | ct0( ui ) | ","; - for ( ui = 1; ui != 0; ui <<= 1 ) { - sout | ui | ct0( ui ) | ","; - } // for - sout | nl; - - li = 0; - sout | li | ct0( li ) | ","; - for ( li = 1; li != 0; li <<= 1 ) { - sout | li | ct0( li ) | ","; - } // for - sout | nl; - uli = 0; - sout | uli | ct0( uli ) | ","; - for ( uli = 1; uli != 0; uli <<= 1 ) { - sout | uli | ct0( uli ) | ","; - } // for - sout | nl; - - lli = 0; - sout | lli | ct0( lli ) | ","; - for ( lli = 1; lli != 0; lli <<= 1 ) { - sout | lli | ct0( lli ) | ","; - } // for - sout | nl; - ulli = 0; - sout | ulli | ct0( ulli ) | ","; - for ( ulli = 1; ulli != 0; ulli <<= 1 ) { - sout | ulli | ct0( ulli ) | ","; - } // for - sout | nl; - - //============================================================ - - sout | nl | "ca1" | nl; - - sc = 0; - for ( int p = 0; p < sizeof(sc) * __CHAR_BIT__ + 1; p += 1, sc = (sc << 1) + 1 ) { - sout | sc | ca1( sc ) | ","; - } // for - sout | nl; - usc = 0; - for ( int p = 0; p < sizeof(sc) * __CHAR_BIT__ + 1; p += 1, usc = (usc << 1) + 1 ) { - sout | usc | ca1( usc ) | ","; - } // for - sout | nl; - - si = 0; - for ( int p = 0; p < sizeof(si) * __CHAR_BIT__ + 1; p += 1, si = (si << 1) + 1 ) { - sout | si | ca1( si ) | ","; - } // for - sout | nl; - usi = 0; - for ( int p = 0; p < sizeof(usi) * __CHAR_BIT__ + 1; p += 1, usi = (usi << 1) + 1 ) { - sout | usi | ca1( usi ) | ","; - } // for - sout | nl; - - i = 0; - for ( int p = 0; p < sizeof(i) * __CHAR_BIT__ + 1; p += 1, i = (i << 1) + 1 ) { - sout | i | ca1( i ) | ","; - } // for - sout | nl; - ui = 0; - for ( int p = 0; p < sizeof(ui) * __CHAR_BIT__ + 1; p += 1, ui = (ui << 1) + 1 ) { - sout | ui | ca1( ui ) | ","; - } // for - sout | nl; - - li = 0; - for ( int p = 0; i < sizeof(li) * __CHAR_BIT__ + 1; p += 1, li = (li << 1) + 1 ) { - sout | li | ca1( li ) | ","; - } // for - sout | nl; - uli = 0; - for ( int p = 0; p < sizeof(li) * __CHAR_BIT__ + 1; p += 1, uli = (uli << 1) + 1 ) { - sout | uli | ca1( uli ) | ","; - } // for - sout | nl; - - lli = 0; - for ( int p = 0; p < sizeof(li) * __CHAR_BIT__ + 1; p += 1, lli = (lli << 1) + 1 ) { - sout | lli | ca1( lli ) | ","; - } // for - sout | nl; - ulli = 0; - for ( int p = 0; p < sizeof(li) * __CHAR_BIT__ + 1; p += 1, ulli = (ulli << 1) + 1 ) { - sout | ulli | ca1( ulli ) | ","; - } // for - sout | nl; - - //============================================================ - - sout | nl | "ca0" | nl; - - sc = 0; - for ( int p = 0; p < sizeof(sc) * __CHAR_BIT__ + 1; p += 1, sc = (sc << 1) + 1 ) { - sout | sc | ca0( sc ) | ","; - } // for - sout | nl; - usc = 0; - for ( int p = 0; p < sizeof(sc) * __CHAR_BIT__ + 1; p += 1, usc = (usc << 1) + 1 ) { - sout | usc | ca0( usc ) | ","; - } // for - sout | nl; - - si = 0; - for ( int p = 0; p < sizeof(si) * __CHAR_BIT__ + 1; p += 1, si = (si << 1) + 1 ) { - sout | si | ca0( si ) | ","; - } // for - sout | nl; - usi = 0; - for ( int p = 0; p < sizeof(si) * __CHAR_BIT__ + 1; p += 1, usi = (usi << 1) + 1 ) { - sout | usi | ca0( usi ) | ","; - } // for - sout | nl; - - i = 0; - for ( int p = 0; p < sizeof(i) * __CHAR_BIT__ + 1; p += 1, i = (i << 1) + 1 ) { - sout | i | ca0( i ) | ","; - } // for - sout | nl; - ui = 0; - for ( int p = 0; p < sizeof(ui) * __CHAR_BIT__ + 1; p += 1, ui = (ui << 1) + 1 ) { - sout | ui | ca0( ui ) | ","; - } // for - sout | nl; - - li = 0; - for ( int p = 0; p < sizeof(li) * __CHAR_BIT__ + 1; p += 1, li = (li << 1) + 1 ) { - sout | li | ca0( li ) | ","; - } // for - sout | nl; - uli = 0; - for ( int p = 0; p < sizeof(li) * __CHAR_BIT__ + 1; p += 1, uli = (uli << 1) + 1 ) { - sout | uli | ca0( uli ) | ","; - } // for - sout | nl; - - lli = 0; - for ( int p = 0; p < sizeof(li) * __CHAR_BIT__ + 1; p += 1, lli = (lli << 1) + 1 ) { - sout | lli | ca0( lli ) | ","; - } // for - sout | nl; - ulli = 0; - for ( int p = 0; p < sizeof(li) * __CHAR_BIT__ + 1; p += 1, ulli = (ulli << 1) + 1 ) { - sout | ulli | ca0( ulli ) | ","; - } // for - sout | nl; - - //============================================================ - - sout | nl | "fls" | nl; - - sc = 0; - sout | sc | fls( sc ) | ","; - for ( sc = 1; sc != 0; sc <<= 1 ) { - sout | sc | fls( sc ) | ","; - } // for - sout | nl; - usc = 0; - sout | usc | fls( usc ) | ","; - for ( usc = 1; usc != 0; usc <<= 1 ) { - sout | usc | fls( usc ) | ","; - } // for - sout | nl; - - si = 0; - sout | si | fls( si ) | ","; - for ( si = 1; si != 0; si <<= 1 ) { - sout | si | fls( si ) | ","; - } // for - sout | nl; - usi = 0; - sout | usi | fls( usi ) | ","; - for ( usi = 1; usi != 0; usi <<= 1 ) { - sout | usi | fls( usi ) | ","; - } // for - sout | nl; - - i = 0; - sout | i | fls( i ) | ","; - for ( i = 1; i != 0; i <<= 1 ) { - sout | i | fls( i ) | ","; - } // for - sout | nl; - ui = 0; - sout | ui | fls( ui ) | ","; - for ( ui = 1; ui != 0; ui <<= 1 ) { - sout | ui | fls( ui ) | ","; - } // for - sout | nl; - - li = 0; - sout | li | fls( li ) | ","; - for ( li = 1; li != 0; li <<= 1 ) { - sout | li | fls( li ) | ","; - } // for - sout | nl; - uli = 0; - sout | uli | fls( uli ) | ","; - for ( uli = 1; uli != 0; uli <<= 1 ) { - sout | uli | fls( uli ) | ","; - } // for - sout | nl; - - lli = 0; - sout | lli | fls( lli ) | ","; - for ( lli = 1; lli != 0; lli <<= 1 ) { - sout | lli | fls( lli ) | ","; - } // for - sout | nl; - ulli = 0; - sout | ulli | fls( ulli ) | ","; - for ( ulli = 1; ulli != 0; ulli <<= 1 ) { - sout | ulli | fls( ulli ) | ","; - } // for - sout | nl; - - //============================================================ - - sout | nl | "fms" | nl; - - sc = 0; - sout | sc | fms( sc ) | ","; - for ( sc = 1; sc != 0; sc <<= 1 ) { - sout | sc | fms( sc ) | ","; - } // for - sout | nl; - usc = 0; - sout | usc | fms( usc ) | ","; - for ( usc = 1; usc != 0; usc <<= 1 ) { - sout | usc | fms( usc ) | ","; - } // for - sout | nl; - - si = 0; - sout | si | fms( si ) | ","; - for ( si = 1; si != 0; si <<= 1 ) { - sout | si | fms( si ) | ","; - } // for - sout | nl; - usi = 0; - sout | usi | fms( usi ) | ","; - for ( usi = 1; usi != 0; usi <<= 1 ) { - sout | usi | fms( usi ) | ","; - } // for - sout | nl; - - i = 0; - sout | i | fms( i ) | ","; - for ( i = 1; i != 0; i <<= 1 ) { - sout | i | fms( i ) | ","; - } // for - sout | nl; - ui = 0; - sout | ui | fms( ui ) | ","; - for ( ui = 1; ui != 0; ui <<= 1 ) { - sout | ui | fms( ui ) | ","; - } // for - sout | nl; - - li = 0; - sout | li | fms( li ) | ","; - for ( li = 1; li != 0; li <<= 1 ) { - sout | li | fms( li ) | ","; - } // for - sout | nl; - uli = 0; - sout | uli | fms( uli ) | ","; - for ( uli = 1; uli != 0; uli <<= 1 ) { - sout | uli | fms( uli ) | ","; - } // for - sout | nl; - - lli = 0; - sout | lli | fms( lli ) | ","; - for ( lli = 1; lli != 0; lli <<= 1 ) { - sout | lli | fms( lli ) | ","; - } // for - sout | nl; - ulli = 0; - sout | ulli | fms( ulli ) | ","; - for ( ulli = 1; ulli != 0; ulli <<= 1 ) { - sout | ulli | fms( ulli ) | ","; - } // for - sout | nl; -} // main - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa bitmanip.cfa" // -// End: // Index: tests/bitmanip1.cfa =================================================================== --- tests/bitmanip1.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/bitmanip1.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,322 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// bitmanip1.cfa -- +// +// Author : Peter A. Buhr +// Created On : Tue Apr 7 21:20:29 2020 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue Apr 7 21:20:57 2020 +// Update Count : 1 +// + +#include +#include + +int main() { + signed char sc; + unsigned char usc; + short int si; + unsigned short int usi; + int i; + unsigned int ui; + long int li; + unsigned long int uli; + long long int lli; + unsigned long long int ulli; + + //============================================================ +#if 1 + sout | "leading0s" | nl | nl; + + sout | "signed char"; + sc = 0; + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | leading0s( sc ); + for ( sc = 1; sc != 0; sc <<= 1 ) { + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | leading0s( sc ); + } // for + sout | nl; + sout | "unsigned char"; + usc = 0; + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | leading0s( usc ); + for ( usc = 1; usc != 0; usc <<= 1 ) { + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | leading0s( usc ); + } // for + sout | nl; + + sout | "short int"; + si = 0; + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | leading0s( si ); + for ( si = 1; si != 0; si <<= 1 ) { + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | leading0s( si ); + } // for + sout | nl; + sout | "unsigned short int"; + usi = 0; + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | leading0s( usi ); + for ( usi = 1; usi != 0; usi <<= 1 ) { + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | leading0s( usi ); + } // for + sout | nl; + + sout | "int"; + i = 0; + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | leading0s( i ); + for ( i = 1; i != 0; i <<= 1 ) { + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | leading0s( i ); + } // for + sout | nl; + sout | "unsigned int"; + ui = 0; + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | leading0s( ui ); + for ( ui = 1; ui != 0; ui <<= 1 ) { + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | leading0s( ui ); + } // for + sout | nl; + + sout | "long int"; + li = 0; + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | leading0s( li ); + for ( li = 1; li != 0; li <<= 1 ) { + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | leading0s( li ); + } // for + sout | nl; + sout | "unsigned long int"; + uli = 0; + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | leading0s( uli ); + for ( uli = 1; uli != 0; uli <<= 1 ) { + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | leading0s( uli ); + } // for + sout | nl; + + sout | "long long int"; + lli = 0; + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | leading0s( lli ); + for ( lli = 1; lli != 0; lli <<= 1 ) { + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | leading0s( lli ); + } // for + sout | nl; + ulli = 0; + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | leading0s( ulli ); + sout | "unsigned long long int"; + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | leading0s( ulli ); + } // for + sout | nl; +#endif // 0 + //============================================================ +#if 1 + sout | nl | "trailing0s" | nl | nl; + + sout | "signed char"; + for ( sc = 1; sc != 0; sc <<= 1 ) { + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | trailing0s( sc ); + } // for + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | trailing0s( sc ); + sout | nl; + sout | "unsigned char"; + for ( usc = 1; usc != 0; usc <<= 1 ) { + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | trailing0s( usc ); + } // for + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | trailing0s( usc ); + sout | nl; + + sout | "short int"; + for ( si = 1; si != 0; si <<= 1 ) { + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | trailing0s( si ); + } // for + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | trailing0s( si ); + sout | nl; + sout | "unsigned short int"; + for ( usi = 1; usi != 0; usi <<= 1 ) { + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | trailing0s( usi ); + } // for + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | trailing0s( usi ); + sout | nl; + + sout | "int"; + for ( i = 1; i != 0; i <<= 1 ) { + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | trailing0s( i ); + } // for + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | trailing0s( i ); + sout | nl; + sout | "unsigned int"; + for ( ui = 1; ui != 0; ui <<= 1 ) { + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | trailing0s( ui ); + } // for + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | trailing0s( ui ); + sout | nl; + + sout | "long int"; + for ( li = 1; li != 0; li <<= 1 ) { + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | trailing0s( li ); + } // for + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | trailing0s( li ); + sout | nl; + sout | "unsigned long int"; + for ( uli = 1; uli != 0; uli <<= 1 ) { + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | trailing0s( uli ); + } // for + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | trailing0s( uli ); + sout | nl; + + sout | "long long int"; + for ( lli = 1; lli != 0; lli <<= 1 ) { + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | trailing0s( lli ); + } // for + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | trailing0s( lli ); + sout | nl; + sout | "unsigned long long int"; + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | trailing0s( ulli ); + } // for + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | trailing0s( ulli ); + sout | nl; +#endif // 0 + //============================================================ +#if 1 + sout | nl | "all0s" | nl | nl; + + sout | "signed char"; + for ( sc = 0; sc != -1hh; sc = (sc << 1) + 1 ) { + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | all0s( sc ); + } // for + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | all0s( sc ); + sout | nl; + sout | "unsigned char"; + for ( usc = 0; usc != -1hh; usc = (usc << 1) + 1 ) { + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | all0s( usc ); + } // for + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | all0s( usc ); + sout | nl; + + sout | "short int"; + for ( si = 0; si != -1h; si = (si << 1) + 1 ) { + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | all0s( si ); + } // for + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | all0s( si ); + sout | nl; + sout | "unsigned short int"; + for ( usi = 0; usi != -1h; usi = (usi << 1) + 1 ) { + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | all0s( usi ); + } // for + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | all0s( usi ); + sout | nl; + + sout | "int"; + for ( i = 0; i != -1; i = (i << 1) + 1 ) { + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | all0s( i ); + } // for + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | all0s( i ); + sout | nl; + sout | "unsigned int"; + for ( ui = 0; ui != -1; ui = (ui << 1) + 1 ) { + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | all0s( ui ); + } // for + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | all0s( ui ); + sout | nl; + + sout | "long int"; + for ( li = 0; li != -1; li = (li << 1) + 1 ) { + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | all0s( li ); + } // for + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | all0s( li ); + sout | nl; + sout | "unsigned long int"; + for ( uli = 0; uli != -1; uli = (uli << 1) + 1 ) { + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | all0s( uli ); + } // for + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | all0s( uli ); + sout | nl; + + sout | "long long int"; + for ( lli = 0; lli != -1; lli = (lli << 1) + 1 ) { + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | all0s( lli ); + } // for + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | all0s( lli ); + sout | nl; + sout | "unsigned long long int"; + for ( ulli = 0; ulli != -1; ulli = (ulli << 1) + 1 ) { + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | all0s( ulli ); + } // for + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | all0s( ulli ); + sout | nl; +#endif // 0 + //============================================================ +#if 1 + sout | nl | "all1s" | nl | nl; + + sout | "signed char"; + for ( sc = 0; sc != -1hh; sc = (sc << 1) + 1 ) { + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | all1s( sc ); + } // for + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | all1s( sc ); + sout | nl; + sout | "unsigned char"; + for ( usc = 0; usc != -1hh; usc = (usc << 1) + 1 ) { + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | all1s( usc ); + } // for + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | all1s( usc ); + sout | nl; + + sout | "short int"; + for ( si = 0; si != -1h; si = (si << 1) + 1 ) { + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | all1s( si ); + } // for + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | all1s( si ); + sout | nl; + sout | "unsigned short int"; + for ( usi = 0; usi != -1h; usi = (usi << 1) + 1 ) { + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | all1s( usi ); + } // for + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | all1s( usi ); + sout | nl; + + sout | "int"; + for ( i = 0; i != -1; i = (i << 1) + 1 ) { + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | all1s( i ); + } // for + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | all1s( i ); + sout | nl; + sout | "unsigned int"; + for ( ui = 0; ui != -1; ui = (ui << 1) + 1 ) { + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | all1s( ui ); + } // for + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | all1s( ui ); + sout | nl; + + sout | "long int"; + for ( li = 0; li != -1; li = (li << 1) + 1 ) { + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | all1s( li ); + } // for + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | all1s( li ); + sout | nl; + sout | "unsigned long int"; + for ( uli = 0; uli != -1; uli = (uli << 1) + 1 ) { + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | all1s( uli ); + } // for + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | all1s( uli ); + sout | nl; + + sout | "long long int"; + for ( lli = 0; lli != -1; lli = (lli << 1) + 1 ) { + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | all1s( lli ); + } // for + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | all1s( lli ); + sout | nl; + sout | "unsigned long long int"; + for ( ulli = 0; ulli != -1; ulli = (ulli << 1) + 1 ) { + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | all1s( ulli ); + } // for + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | all1s( ulli ); + sout | nl; +#endif // 0 +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa bitmanip1.cfa" // +// End: // Index: tests/bitmanip2.cfa =================================================================== --- tests/bitmanip2.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/bitmanip2.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,352 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// bitmanip2.cfa -- +// +// Author : Peter A. Buhr +// Created On : Tue Apr 7 21:21:20 2020 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue Apr 7 21:21:40 2020 +// Update Count : 1 +// + +#include +#include + +int main() { + signed char sc; + unsigned char usc; + short int si; + unsigned short int usi; + int i; + unsigned int ui; + long int li; + unsigned long int uli; + long long int lli; + unsigned long long int ulli; + + //============================================================ +#if 1 + sout | nl | "low0" | nl | nl; + + sout | "signed char"; + sc = -1; + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | low0( sc ); + for ( sc <<= 1; sc != -1hh; sc = (sc << 1) | 1 ) { + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | low0( sc ); + } // for + sout | nl; + sout | "unsigned char"; + usc = -1; + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | low0( usc ); + for ( usc <<= 1; usc != -1hh; usc = (usc << 1) | 1 ) { + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | low0( usc ); + } // for + sout | nl; + + sout | "short int"; + si = -1; + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | low0( si ); + for ( si <<= 1; si != -1h; si = (si << 1) | 1 ) { + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | low0( si ); + } // for + sout | nl; + sout | "unsigned short int"; + usi = -1; + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | low0( usi ); + for ( usi <<= 1; usi != -1h; usi = (usi << 1) | 1 ) { + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | low0( usi ); + } // for + sout | nl; + + sout | "int"; + i = -1; + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | low0( i ); + for ( i <<= 1; i != -1; i = (i << 1) | 1 ) { + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | low0( i ); + } // for + sout | nl; + sout | "unsigned int"; + ui = -1; + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | low0( ui ); + for ( ui <<= 1; ui != -1; ui = (ui << 1) | 1 ) { + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | low0( ui ); + } // for + sout | nl; + + sout | "long int"; + li = -1; + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | low0( li ); + for ( li <<= 1; li != -1; li = (li << 1) | 1 ) { + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | low0( li ); + } // for + sout | nl; + sout | "unsigned long int"; + uli = -1; + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | low0( uli ); + for ( uli <<= 1; uli != -1; uli = (uli << 1) | 1 ) { + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | low0( uli ); + } // for + sout | nl; + + sout | "long long int"; + lli = -1; + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | low0( lli ); + for ( lli <<= 1; lli != -1; lli = (lli << 1) | 1 ) { + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | low0( lli ); + } // for + sout | nl; + sout | "unsigned long long int"; + ulli = -1; + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | low0( ulli ); + for ( ulli <<= 1; ulli != -1; ulli = (ulli << 1) | 1 ) { + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | low0( ulli ); + } // for + sout | nl; +#endif // 0 + //============================================================ +#if 1 + sout | nl | "low1" | nl | nl; + + sout | "signed char"; + sc = 0; + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | low1( sc ); + for ( sc = 1; sc != 0; sc <<= 1 ) { + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | low1( sc ); + } // for + sout | nl; + sout | "unsigned char"; + usc = 0; + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | low1( usc ); + for ( usc = 1; usc != 0; usc <<= 1 ) { + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | low1( usc ); + } // for + sout | nl; + + sout | "short int"; + si = 0; + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | low1( si ); + for ( si = 1; si != 0; si <<= 1 ) { + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | low1( si ); + } // for + sout | nl; + sout | "unsigned short int"; + usi = 0; + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | low1( usi ); + for ( usi = 1; usi != 0; usi <<= 1 ) { + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | low1( usi ); + } // for + sout | nl; + + sout | "int"; + i = 0; + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | low1( i ); + for ( i = 1; i != 0; i <<= 1 ) { + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | low1( i ); + } // for + sout | nl; + sout | "unsigned int"; + ui = 0; + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | low1( ui ); + for ( ui = 1; ui != 0; ui <<= 1 ) { + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | low1( ui ); + } // for + sout | nl; + + sout | "long int"; + li = 0; + sout | wd(__bitsizeof(li)+2, pad0(bin(i))) | low1( li ); + for ( li = 1; li != 0; li <<= 1 ) { + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | low1( li ); + } // for + sout | nl; + sout | "unsigned long int"; + uli = 0; + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | low1( uli ); + for ( uli = 1; uli != 0; uli <<= 1 ) { + sout | wd(__bitsizeof(uli)+2, pad0(bin(i))) | low1( uli ); + } // for + sout | nl; + + sout | "long long int"; + lli = 0; + sout | wd(__bitsizeof(lli)+2, pad0(bin(i))) | low1( lli ); + for ( lli = 1; lli != 0; lli <<= 1 ) { + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | low1( lli ); + } // for + sout | nl; + sout | "unsigned long long int"; + ulli = 0; + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | low1( ulli ); + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | low1( ulli ); + } // for + sout | nl; +#endif // 0 + //============================================================ +#if 1 + sout | nl | "high0" | nl | nl; + + sout | "signed char"; + sc = -1; + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | high0( sc ); + for ( sc <<= 1; sc != -1hh; sc = (sc << 1) | 1 ) { + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | high0( sc ); + } // for + sout | nl; + sout | "unsigned char"; + usc = -1; + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | high0( usc ); + for ( usc <<= 1; usc != -1hh; usc = (usc << 1) | 1 ) { + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | high0( usc ); + } // for + sout | nl; + + sout | "short int"; + si = -1; + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | high0( si ); + for ( si <<= 1; si != -1h; si = (si << 1) | 1 ) { + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | high0( si ); + } // for + sout | nl; + sout | "unsigned short int"; + usi = -1; + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | high0( usi ); + for ( usi <<= 1; usi != -1h; usi = (usi << 1) | 1 ) { + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | high0( usi ); + } // for + sout | nl; + + sout | "int"; + i = -1; + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | high0( i ); + for ( i <<= 1; i != -1; i = (i << 1) | 1 ) { + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | high0( i ); + } // for + sout | nl; + sout | "unsigned int"; + ui = -1; + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | high0( ui ); + for ( i <<= 1; i != -1; i = (i << 1) | 1 ) { + sout | wd(__bitsizeof(ui)+2, pad0(bin(i))) | high0( ui ); + } // for + sout | nl; + + sout | "long int"; + li = -1; + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | high0( li ); + for ( li <<= 1; li != -1; li = (li << 1) | 1 ) { + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | high0( li ); + } // for + sout | nl; + sout | "unsigned long int"; + uli = -1; + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | high0( uli ); + for ( uli <<= 1; uli != -1; uli = (uli << 1) | 1 ) { + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | high0( uli ); + } // for + sout | nl; + + sout | "long long int"; + lli = -1; + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | high0( lli ); + for ( lli <<= 1; lli != -1; lli = (lli << 1) | 1 ) { + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | high0( lli ); + } // for + sout | nl; + sout | "unsigned long long int"; + ulli = -1; + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | high0( ulli ); + for ( ulli <<= 1; ulli != -1; ulli = (ulli << 1) | 1 ) { + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | high0( ulli ); + } // for + sout | nl; +#endif // 0 + //============================================================ +#if 1 + sout | nl | "high1" | nl | nl; + + sout | "signed char"; + sc = 0; + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | high1( sc ); + for ( sc = 1; sc != 0; sc <<= 1 ) { + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | high1( sc ); + } // for + sout | nl; + sout | "unsigned char"; + usc = 0; + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | high1( usc ); + for ( usc = 1; usc != 0; usc <<= 1 ) { + sout | wd(__bitsizeof(usc)+2, pad0(bin(usc))) | high1( usc ); + } // for + sout | nl; + + sout | "short int"; + si = 0; + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | high1( si ); + for ( si = 1; si != 0; si <<= 1 ) { + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | high1( si ); + } // for + sout | nl; + sout | "unsigned short int"; + usi = 0; + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | high1( usi ); + for ( usi = 1; usi != 0; usi <<= 1 ) { + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | high1( usi ); + } // for + sout | nl; + + sout | "int"; + i = 0; + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | high1( i ); + for ( i = 1; i != 0; i <<= 1 ) { + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | high1( i ); + } // for + sout | nl; + sout | "unsigned int"; + ui = 0; + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | high1( ui ); + for ( ui = 1; ui != 0; ui <<= 1 ) { + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | high1( ui ); + } // for + sout | nl; + + sout | "long int"; + li = 0; + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | high1( li ); + for ( li = 1; li != 0; li <<= 1 ) { + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | high1( li ); + } // for + sout | nl; + sout | "unsigned long int"; + uli = 0; + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | high1( uli ); + for ( uli = 1; uli != 0; uli <<= 1 ) { + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | high1( uli ); + } // for + sout | nl; + + sout | "long long int"; + lli = 0; + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | high1( lli ); + for ( lli = 1; lli != 0; lli <<= 1 ) { + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | high1( lli ); + } // for + sout | nl; + sout | "unsigned long long int"; + ulli = 0; + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | high1( ulli ); + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | high1( ulli ); + } // for + sout | nl; +#endif // 0 +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa bitmanip2.cfa" // +// End: // Index: tests/bitmanip3.cfa =================================================================== --- tests/bitmanip3.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/bitmanip3.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,492 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// bitmanip3.cfa -- +// +// Author : Peter A. Buhr +// Created On : Tue Apr 7 21:22:59 2020 +// Last Modified By : Peter A. Buhr +// Last Modified On : Tue Apr 21 16:25:09 2020 +// Update Count : 61 +// + +#include +#include + +int main() { + bool b1, b2; + signed char sc, scr1, scr2, scr3; + unsigned char uc, ucr1, ucr2, ucr3; + short int si, sir1, sir2, sir3; + unsigned short int usi, usir1, usir2, usir3; + int i, ir1, ir2, ir3; + unsigned int ui, uir1, uir2, uir3; + long int li, lir1, lir2, lir3; + unsigned long int uli, ulir1, ulir2, ulir3; + long long int lli, llir1, llir2, llir3; + unsigned long long int ulli, ullir1, ullir2, ullir3; + + //============================================================ +#if 1 + sout | nl | "is_pow2" | nl | nl; + + sout | "signed char"; + sc = 0; + b1 = is_pow2( sc ), b2 = is_pow2( sc + 13hh ); + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | b1 | wd(__bitsizeof(sc)+2, pad0(bin(sc + 13hh))) | b2; + for ( sc = 1; sc != 0; sc <<= 1 ) { + b1 = is_pow2( sc ), b2 = is_pow2( sc + 13hh ); + sout | wd(__bitsizeof(sc)+2, pad0(bin(sc))) | b1 | wd(__bitsizeof(sc)+2, pad0(bin(sc + 13hh))) | b2; + } // for + sout | nl; + sout | "unsigned char"; + uc = 0; + b1 = is_pow2( uc ), b2 = is_pow2( uc + 13hh ); + sout | wd(__bitsizeof(uc)+2, pad0(bin(uc))) | b1 | wd(__bitsizeof(uc)+2, pad0(bin(uc + 13hh))) | b2; + for ( uc = 1; uc != 0; uc <<= 1 ) { + b1 = is_pow2( uc ), b2 = is_pow2( uc + 13hh ); + sout | wd(__bitsizeof(uc)+2, pad0(bin(uc))) | b1 | wd(__bitsizeof(uc)+2, pad0(bin(uc + 13hh))) | b2; + } // for + sout | nl; + + sout | "short int"; + si = 0; + b1 = is_pow2( si ), b2 = is_pow2( si + 13hh ); + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | b1 | wd(__bitsizeof(si)+2, pad0(bin(si + 13h))) | b2; + for ( si = 1; si != 0; si <<= 1 ) { + b1 = is_pow2( si ), b2 = is_pow2( si + 13hh ); + sout | wd(__bitsizeof(si)+2, pad0(bin(si))) | b1 | wd(__bitsizeof(si)+2, pad0(bin(si + 13h))) | b2; + } // for + sout | nl; + sout | "unsigned short int"; + usi = 0; + b1 = is_pow2( usi ), b2 = is_pow2( usi + 13hh ); + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | b1 | wd(__bitsizeof(usi)+2, pad0(bin(usi + 13hh))) | b2; + for ( usi = 1; usi != 0; usi <<= 1 ) { + b1 = is_pow2( usi ), b2 = is_pow2( usi + 13hh ); + sout | wd(__bitsizeof(usi)+2, pad0(bin(usi))) | b1 | wd(__bitsizeof(usi)+2, pad0(bin(usi + 13hh))) | b2; + } // for + sout | nl; + + sout | "int"; + i = 0; + b1 = is_pow2( i ), b2 = is_pow2( i + 13hh ); + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | b1 | wd(__bitsizeof(i)+2, pad0(bin(i + 13h))) | b2; + for ( i = 1; i != 0; i <<= 1 ) { + b1 = is_pow2( i ), b2 = is_pow2( i + 13hh ); + sout | wd(__bitsizeof(i)+2, pad0(bin(i))) | b1 | wd(__bitsizeof(i)+2, pad0(bin(i + 13h))) | b2; + } // for + sout | nl; + sout | "unsigned int"; + ui = 0; + b1 = is_pow2( ui ), b2 = is_pow2( ui + 13hh ); + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | b1 | wd(__bitsizeof(ui)+2, pad0(bin(ui + 13hh))) | b2; + for ( ui = 1; ui != 0; ui <<= 1 ) { + b1 = is_pow2( ui ), b2 = is_pow2( ui + 13hh ); + sout | wd(__bitsizeof(ui)+2, pad0(bin(ui))) | b1 | wd(__bitsizeof(ui)+2, pad0(bin(ui + 13hh))) | b2; + } // for + sout | nl; + + sout | "long int"; + li = 0; + b1 = is_pow2( li ), b2 = is_pow2( li + 13hh ); + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | b1 | wd(__bitsizeof(li)+2, pad0(bin(li + 13h))) | b2; + for ( li = 1; li != 0; li <<= 1 ) { + b1 = is_pow2( li ), b2 = is_pow2( li + 13hh ); + sout | wd(__bitsizeof(li)+2, pad0(bin(li))) | b1 | wd(__bitsizeof(li)+2, pad0(bin(li + 13h))) | b2; + } // for + sout | nl; + sout | "unsigned long int"; + uli = 0; + b1 = is_pow2( uli ), b2 = is_pow2( uli + 13hh ); + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | b1 | wd(__bitsizeof(uli)+2, pad0(bin(uli + 13h))) | b2; + for ( uli = 1; uli != 0; uli <<= 1 ) { + b1 = is_pow2( uli ), b2 = is_pow2( uli + 13hh ); + sout | wd(__bitsizeof(uli)+2, pad0(bin(uli))) | b1 | wd(__bitsizeof(uli)+2, pad0(bin(uli + 13h))) | b2; + } // for + sout | nl; + + sout | "long long int"; + lli = 0; + b1 = is_pow2( lli ), b2 = is_pow2( lli + 13hh ); + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | b1 | wd(__bitsizeof(lli)+2, pad0(bin(lli + 13h))) | b2; + for ( lli = 1; lli != 0; lli <<= 1 ) { + b1 = is_pow2( lli ), b2 = is_pow2( lli + 13hh ); + sout | wd(__bitsizeof(lli)+2, pad0(bin(lli))) | b1 | wd(__bitsizeof(lli)+2, pad0(bin(lli + 13h))) | b2; + } // for + sout | nl; + sout | "unsigned long long int"; + ulli = 0; + b1 = is_pow2( ulli ), b2 = is_pow2( ulli + 13hh ); + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | b1 | wd(__bitsizeof(ulli)+2, pad0(bin(ulli + 13h))) | b2; + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + b1 = is_pow2( ulli ), b2 = is_pow2( ulli + 13hh ); + sout | wd(__bitsizeof(ulli)+2, pad0(bin(ulli))) | b1 | wd(__bitsizeof(ulli)+2, pad0(bin(ulli + 13h))) | b2; + } // for + sout | nl; +#endif // 0 + //============================================================ +#if 1 + sout | nl | "floor2" | nl | nl; + + printf( "signed char\n" ); + sc = 0; + scr1 = floor2( sc, sc ), scr2 = floor2( sc + 2hh, sc ), scr3 = floor2( -sc - 2hh, sc ); + printf( "floor2(%hhd, %hhd) = %hhd, floor2(%hhd, %hhd) = %hhd, floor2(%hhd, %hhd) = %hhd\n", sc, sc, scr1, sc + 2hh, sc, scr2, -sc - 2hh, sc, scr3 ); + for ( sc = 1; sc != 0; sc <<= 1 ) { + scr1 = floor2( sc, sc ); scr2 = floor2( sc + 2hh, sc ); scr3 = floor2( -sc - 2hh, sc ); + printf( "floor2(%hhd, %hhd) = %hhd, floor2(%hhd, %hhd) = %hhd, floor2(%hhd, %hhd) = %hhd\n", sc, sc, scr1, sc + 2hh, sc, scr2, -sc - 2hh, sc, scr3 ); + } // for + printf( "\n" ); + + printf( "unsigned char\n" ); + uc = 0; + ucr1 = floor2( uc, uc ), ucr2 = floor2( uc + 2hh, uc ), ucr3 = floor2( -uc - 2hh, uc ); + printf( "floor2(%hhu, %hhu) = %hhu, floor2(%hhu, %hhu) = %hhu, floor2(%hhu, %hhu) = %hhu\n", uc, uc, ucr1, uc + 2uhh, uc, ucr2, -uc - 2uhh, uc, ucr3 ); + for ( uc = 1; uc != 0; uc <<= 1 ) { + ucr1 = floor2( uc, uc ); ucr2 = floor2( uc + 2hh, uc ); ucr3 = floor2( -uc - 2hh, uc ); + printf( "floor2(%hhu, %hhu) = %hhu, floor2(%hhu, %hhu) = %hhu, floor2(%hhu, %hhu) = %hhu\n", uc, uc, ucr1, uc + 2uhh, uc, ucr2, -uc - 2uhh, uc, ucr3 ); + } // for + printf( "\n" ); + + printf( "short int\n" ); + si = 0; + sir1 = floor2( si, si ), sir2 = floor2( si + 2hh, si ), sir3 = floor2( -si - 2hh, si ); + printf( "floor2(%hd, %hd) = %hd, floor2(%hd, %hd) = %hd, floor2(%hd, %hd) = %hd\n", si, si, sir1, si + 2h, si, sir2, -si - 2h, si, sir3 ); + for ( si = 1; si != 0; si <<= 1 ) { + sir1 = floor2( si, si ); sir2 = floor2( si + 2hh, si ); sir3 = floor2( -si - 2hh, si ); + printf( "floor2(%hd, %hd) = %hd, floor2(%hd, %hd) = %hd, floor2(%hd, %hd) = %hd\n", si, si, sir1, si + 2h, si, sir2, -si - 2h, si, sir3 ); + } // for + printf( "\n" ); + + printf( "unsigned short int\n" ); + usi = 0; + usir1 = floor2( usi, usi ), usir2 = floor2( usi + 2hh, usi ), usir3 = floor2( -usi - 2hh, usi ); + printf( "floor2(%hu, %hu) = %hu, floor2(%hu, %hu) = %hu, floor2(%hu, %hu) = %hu\n", usi, usi, usir1, usi + 2uh, usi, usir2, -usi - 2uh, usi, usir3 ); + for ( usi = 1; usi != 0; usi <<= 1 ) { + usir1 = floor2( usi, usi ); usir2 = floor2( usi + 2hh, usi ); usir3 = floor2( -usi - 2hh, usi ); + printf( "floor2(%hu, %hu) = %hu, floor2(%hu, %hu) = %hu, floor2(%hu, %hu) = %hu\n", usi, usi, usir1, usi + 2uh, usi, usir2, -usi - 2uh, usi, usir3 ); + } // for + printf( "\n" ); + + printf( "int\n" ); + i = 0; + ir1 = floor2( i, i ), ir2 = floor2( i + 2hh, i ), ir3 = floor2( -i - 2hh, i ); + printf( "floor2(%d, %d) = %d, floor2(%d, %d) = %d, floor2(%d, %d) = %d\n", i, i, ir1, i + 2h, i, ir2, -i - 2h, i, ir3 ); + for ( i = 1; i != 0; i <<= 1 ) { + ir1 = floor2( i, i ); ir2 = floor2( i + 2hh, i ); ir3 = floor2( -i - 2hh, i ); + printf( "floor2(%d, %d) = %d, floor2(%d, %d) = %d, floor2(%d, %d) = %d\n", i, i, ir1, i + 2h, i, ir2, -i - 2h, i, ir3 ); + } // for + printf( "\n" ); + + printf( "unsigned int\n" ); + ui = 0; + uir1 = floor2( ui, ui ), uir2 = floor2( ui + 2hh, ui ), uir3 = floor2( -ui - 2hh, ui ); + printf( "floor2(%u, %u) = %u, floor2(%u, %u) = %u, floor2(%u, %u) = %u\n", ui, ui, uir1, ui + 2h, ui, uir2, -ui - 2h, ui, uir3 ); + for ( ui = 1; ui != 0; ui <<= 1 ) { + uir1 = floor2( ui, ui ); uir2 = floor2( ui + 2hh, ui ); uir3 = floor2( -ui - 2hh, ui ); + printf( "floor2(%u, %u) = %u, floor2(%u, %u) = %u, floor2(%u, %u) = %u\n", ui, ui, uir1, ui + 2h, ui, uir2, -ui - 2h, ui, uir3 ); + } // for + printf( "\n" ); + + printf( "long int\n" ); + li = 0; + lir1 = floor2( li, li ), lir2 = floor2( li + 2hh, li ), lir3 = floor2( -li - 2hh, li ); + printf( "floor2(%ld, %ld) = %ld, floor2(%ld, %ld) = %ld, floor2(%ld, %ld) = %ld\n", li, li, lir1, li + 2h, li, lir2, -li - 2h, li, lir3 ); + for ( li = 1; li != 0; li <<= 1 ) { + lir1 = floor2( li, li ); lir2 = floor2( li + 2hh, li ); lir3 = floor2( -li - 2hh, li ); + printf( "floor2(%ld, %ld) = %ld, floor2(%ld, %ld) = %ld, floor2(%ld, %ld) = %ld\n", li, li, lir1, li + 2h, li, lir2, -li - 2h, li, lir3 ); + } // for + printf( "\n" ); + + printf( "unsigned long int\n" ); + uli = 0; + ulir1 = floor2( uli, uli ), ulir2 = floor2( uli + 2hh, uli ), ulir3 = floor2( -uli - 2hh, uli ); + printf( "floor2(%lu, %lu) = %lu, floor2(%lu, %lu) = %lu, floor2(%lu, %lu) = %lu\n", uli, uli, ulir1, uli + 2h, uli, ulir2, -uli - 2h, uli, ulir3 ); + for ( uli = 1; uli != 0; uli <<= 1 ) { + ulir1 = floor2( uli, uli ); ulir2 = floor2( uli + 2hh, uli ); ulir3 = floor2( -uli - 2hh, uli ); + printf( "floor2(%lu, %lu) = %lu, floor2(%lu, %lu) = %lu, floor2(%lu, %lu) = %lu\n", uli, uli, ulir1, uli + 2h, uli, ulir2, -uli - 2h, uli, ulir3 ); + } // for + printf( "\n" ); + + printf( "long long int\n" ); + lli = 0; + llir1 = floor2( lli, lli ), llir2 = floor2( lli + 2hh, lli ), llir3 = floor2( -lli - 2hh, lli ); + printf( "floor2(%lld, %lld) = %lld, floor2(%lld, %lld) = %lld, floor2(%lld, %lld) = %lld\n", lli, lli, llir1, lli + 2h, lli, llir2, -lli - 2h, lli, llir3 ); + for ( lli = 1; lli != 0; lli <<= 1 ) { + llir1 = floor2( lli, lli ); llir2 = floor2( lli + 2hh, lli ); llir3 = floor2( -lli - 2hh, lli ); + printf( "floor2(%lld, %lld) = %lld, floor2(%lld, %lld) = %lld, floor2(%lld, %lld) = %lld\n", lli, lli, llir1, lli + 2h, lli, llir2, -lli - 2h, lli, llir3 ); + } // for + printf( "\n" ); + + printf( "unsigned long long int\n" ); + ulli = 0; + ullir1 = floor2( ulli, ulli ), ullir2 = floor2( ulli + 2hh, ulli ), ullir3 = floor2( -ulli - 2hh, ulli ); + printf( "floor2(%llu, %llu) = %llu, floor2(%llu, %llu) = %llu, floor2(%llu, %llu) = %llu\n", ulli, ulli, ullir1, ulli + 2h, ulli, ullir2, -ulli - 2h, ulli, ullir3 ); + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + ullir1 = floor2( ulli, ulli ); ullir2 = floor2( ulli + 2hh, ulli ); ullir3 = floor2( -ulli - 2hh, ulli ); + printf( "floor2(%llu, %llu) = %llu, floor2(%llu, %llu) = %llu, floor2(%llu, %llu) = %llu\n", ulli, ulli, ullir1, ulli + 2h, ulli, ullir2, -ulli - 2h, ulli, ullir3 ); + } // for + printf( "\n" ); +#endif // 0 + //============================================================ +#if 1 + sout | nl | "floor" | nl | nl; + + printf( "signed char\n" ); + for ( sc = 1; sc != 0; sc <<= 1 ) { + scr1 = floor( sc, sc ); scr2 = floor( sc + 2hh, sc ); scr3 = floor( -sc - 2hh, sc ); + printf( "floor(%hhd, %hhd) = %hhd, floor(%hhd, %hhd) = %hhd, floor(%hhd, %hhd) = %hhd\n", sc, sc, scr1, sc + 2hh, sc, scr2, -sc - 2hh, sc, scr3 ); + } // for + printf( "\n" ); + + printf( "unsigned char\n" ); + for ( uc = 1; uc != 0; uc <<= 1 ) { + ucr1 = floor( uc, uc ); ucr2 = floor( uc + 2hh, uc ); ucr3 = floor( -uc - 2hh, uc ); + printf( "floor(%hhu, %hhu) = %hhu, floor(%hhu, %hhu) = %hhu, floor(%hhu, %hhu) = %hhu\n", uc, uc, ucr1, uc + 2uhh, uc, ucr2, -uc - 2uhh, uc, ucr3 ); + } // for + printf( "\n" ); + + printf( "short int\n" ); + for ( si = 1; si != 0; si <<= 1 ) { + sir1 = floor( si, si ); sir2 = floor( si + 2hh, si ); sir3 = floor( -si - 2hh, si ); + printf( "floor(%hd, %hd) = %hd, floor(%hd, %hd) = %hd, floor(%hd, %hd) = %hd\n", si, si, sir1, si + 2h, si, sir2, -si - 2h, si, sir3 ); + } // for + printf( "\n" ); + + printf( "unsigned short int\n" ); + for ( usi = 1; usi != 0; usi <<= 1 ) { + usir1 = floor( usi, usi ); usir2 = floor( usi + 2hh, usi ); usir3 = floor( -usi - 2hh, usi ); + printf( "floor(%hu, %hu) = %hu, floor(%hu, %hu) = %hu, floor(%hu, %hu) = %hu\n", usi, usi, usir1, usi + 2uh, usi, usir2, -usi - 2uh, usi, usir3 ); + } // for + printf( "\n" ); + + printf( "int\n" ); + for ( i = 1; i != 0; i <<= 1 ) { + ir1 = floor( i, i ); ir2 = floor( i + 2hh, i ); ir3 = floor( -i - 2hh, i ); + printf( "floor(%d, %d) = %d, floor(%d, %d) = %d, floor(%d, %d) = %d\n", i, i, ir1, i + 2h, i, ir2, -i - 2h, i, ir3 ); + } // for + printf( "\n" ); + + printf( "unsigned int\n" ); + for ( ui = 1; ui != 0; ui <<= 1 ) { + uir1 = floor( ui, ui ); uir2 = floor( ui + 2hh, ui ); uir3 = floor( -ui - 2hh, ui ); + printf( "floor(%u, %u) = %u, floor(%u, %u) = %u, floor(%u, %u) = %u\n", ui, ui, uir1, ui + 2h, ui, uir2, -ui - 2h, ui, uir3 ); + } // for + printf( "\n" ); + + printf( "long int\n" ); + for ( li = 1; li != 0; li <<= 1 ) { + lir1 = floor( li, li ); lir2 = floor( li + 2hh, li ); lir3 = floor( -li - 2hh, li ); + printf( "floor(%ld, %ld) = %ld, floor(%ld, %ld) = %ld, floor(%ld, %ld) = %ld\n", li, li, lir1, li + 2h, li, lir2, -li - 2h, li, lir3 ); + } // for + printf( "\n" ); + + printf( "unsigned long int\n" ); + for ( uli = 1; uli != 0; uli <<= 1 ) { + ulir1 = floor( uli, uli ); ulir2 = floor( uli + 2hh, uli ); ulir3 = floor( -uli - 2hh, uli ); + printf( "floor(%lu, %lu) = %lu, floor(%lu, %lu) = %lu, floor(%lu, %lu) = %lu\n", uli, uli, ulir1, uli + 2h, uli, ulir2, -uli - 2h, uli, ulir3 ); + } // for + printf( "\n" ); + + printf( "long long int\n" ); + for ( lli = 1; lli != 0; lli <<= 1 ) { + llir1 = floor( lli, lli ); llir2 = floor( lli + 2hh, lli ); llir3 = floor( -lli - 2hh, lli ); + printf( "floor(%lld, %lld) = %lld, floor(%lld, %lld) = %lld, floor(%lld, %lld) = %lld\n", lli, lli, llir1, lli + 2h, lli, llir2, -lli - 2h, lli, llir3 ); + } // for + printf( "\n" ); + + printf( "unsigned long long int\n" ); + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + ullir1 = floor( ulli, ulli ); ullir2 = floor( ulli + 2hh, ulli ); ullir3 = floor( -ulli - 2hh, ulli ); + printf( "floor(%llu, %llu) = %llu, floor(%llu, %llu) = %llu, floor(%llu, %llu) = %llu\n", ulli, ulli, ullir1, ulli + 2h, ulli, ullir2, -ulli - 2h, ulli, ullir3 ); + } // for + printf( "\n" ); +#endif // 0 + //============================================================ +#if 1 + sout | nl | "ceiling2" | nl | nl; + + printf( "signed char\n" ); + sc = 0; + scr1 = ceiling2( sc, sc ), scr2 = ceiling2( sc + 2hh, sc ), scr3 = ceiling2( -sc - 2hh, sc ); + printf( "ceiling2(%hhd, %hhd) = %hhd, ceiling2(%hhd, %hhd) = %hhd, ceiling2(%hhd, %hhd) = %hhd\n", sc, sc, scr1, sc + 2hh, sc, scr2, -sc - 2hh, sc, scr3 ); + for ( sc = 1; sc != 0; sc <<= 1 ) { + scr1 = ceiling2( sc, sc ); scr2 = ceiling2( sc + 2hh, sc ); scr3 = ceiling2( -sc - 2hh, sc ); + printf( "ceiling2(%hhd, %hhd) = %hhd, ceiling2(%hhd, %hhd) = %hhd, ceiling2(%hhd, %hhd) = %hhd\n", sc, sc, scr1, sc + 2hh, sc, scr2, -sc - 2hh, sc, scr3 ); + } // for + printf( "\n" ); + + printf( "unsigned char\n" ); + uc = 0; + ucr1 = ceiling2( uc, uc ), ucr2 = ceiling2( uc + 2hh, uc ), ucr3 = ceiling2( -uc - 2hh, uc ); + printf( "ceiling2(%hhu, %hhu) = %hhu, ceiling2(%hhu, %hhu) = %hhu, ceiling2(%hhu, %hhu) = %hhu\n", uc, uc, ucr1, uc + 2uhh, uc, ucr2, -uc - 2uhh, uc, ucr3 ); + for ( uc = 1; uc != 0; uc <<= 1 ) { + ucr1 = ceiling2( uc, uc ); ucr2 = ceiling2( uc + 2hh, uc ); ucr3 = ceiling2( -uc - 2hh, uc ); + printf( "ceiling2(%hhu, %hhu) = %hhu, ceiling2(%hhu, %hhu) = %hhu, ceiling2(%hhu, %hhu) = %hhu\n", uc, uc, ucr1, uc + 2uhh, uc, ucr2, -uc - 2uhh, uc, ucr3 ); + } // for + printf( "\n" ); + + printf( "short int\n" ); + si = 0; + sir1 = ceiling2( si, si ), sir2 = ceiling2( si + 2hh, si ), sir3 = ceiling2( -si - 2hh, si ); + printf( "ceiling2(%hd, %hd) = %hd, ceiling2(%hd, %hd) = %hd, ceiling2(%hd, %hd) = %hd\n", si, si, sir1, si + 2h, si, sir2, -si - 2h, si, sir3 ); + for ( si = 1; si != 0; si <<= 1 ) { + sir1 = ceiling2( si, si ); sir2 = ceiling2( si + 2hh, si ); sir3 = ceiling2( -si - 2hh, si ); + printf( "ceiling2(%hd, %hd) = %hd, ceiling2(%hd, %hd) = %hd, ceiling2(%hd, %hd) = %hd\n", si, si, sir1, si + 2h, si, sir2, -si - 2h, si, sir3 ); + } // for + printf( "\n" ); + + printf( "unsigned short int\n" ); + usi = 0; + usir1 = ceiling2( usi, usi ), usir2 = ceiling2( usi + 2hh, usi ), usir3 = ceiling2( -usi - 2hh, usi ); + printf( "ceiling2(%hu, %hu) = %hu, ceiling2(%hu, %hu) = %hu, ceiling2(%hu, %hu) = %hu\n", usi, usi, usir1, usi + 2uh, usi, usir2, -usi - 2uh, usi, usir3 ); + for ( usi = 1; usi != 0; usi <<= 1 ) { + usir1 = ceiling2( usi, usi ); usir2 = ceiling2( usi + 2hh, usi ); usir3 = ceiling2( -usi - 2hh, usi ); + printf( "ceiling2(%hu, %hu) = %hu, ceiling2(%hu, %hu) = %hu, ceiling2(%hu, %hu) = %hu\n", usi, usi, usir1, usi + 2uh, usi, usir2, -usi - 2uh, usi, usir3 ); + } // for + printf( "\n" ); + + printf( "int\n" ); + i = 0; + ir1 = ceiling2( i, i ), ir2 = ceiling2( i + 2hh, i ), ir3 = ceiling2( -i - 2hh, i ); + printf( "ceiling2(%d, %d) = %d, ceiling2(%d, %d) = %d, ceiling2(%d, %d) = %d\n", i, i, ir1, i + 2h, i, ir2, -i - 2h, i, ir3 ); + for ( i = 1; i != 0; i <<= 1 ) { + ir1 = ceiling2( i, i ); ir2 = ceiling2( i + 2hh, i ); ir3 = ceiling2( -i - 2hh, i ); + printf( "ceiling2(%d, %d) = %d, ceiling2(%d, %d) = %d, ceiling2(%d, %d) = %d\n", i, i, ir1, i + 2h, i, ir2, -i - 2h, i, ir3 ); + } // for + printf( "\n" ); + + printf( "unsigned int\n" ); + ui = 0; + uir1 = ceiling2( ui, ui ), uir2 = ceiling2( ui + 2hh, ui ), uir3 = ceiling2( -ui - 2hh, ui ); + printf( "ceiling2(%u, %u) = %u, ceiling2(%u, %u) = %u, ceiling2(%u, %u) = %u\n", ui, ui, uir1, ui + 2h, ui, uir2, -ui - 2h, ui, uir3 ); + for ( ui = 1; ui != 0; ui <<= 1 ) { + uir1 = ceiling2( ui, ui ); uir2 = ceiling2( ui + 2hh, ui ); uir3 = ceiling2( -ui - 2hh, ui ); + printf( "ceiling2(%u, %u) = %u, ceiling2(%u, %u) = %u, ceiling2(%u, %u) = %u\n", ui, ui, uir1, ui + 2h, ui, uir2, -ui - 2h, ui, uir3 ); + } // for + printf( "\n" ); + + printf( "long int\n" ); + li = 0; + lir1 = ceiling2( li, li ), lir2 = ceiling2( li + 2hh, li ), lir3 = ceiling2( -li - 2hh, li ); + printf( "ceiling2(%ld, %ld) = %ld, ceiling2(%ld, %ld) = %ld, ceiling2(%ld, %ld) = %ld\n", li, li, lir1, li + 2h, li, lir2, -li - 2h, li, lir3 ); + for ( li = 1; li != 0; li <<= 1 ) { + lir1 = ceiling2( li, li ); lir2 = ceiling2( li + 2hh, li ); lir3 = ceiling2( -li - 2hh, li ); + printf( "ceiling2(%ld, %ld) = %ld, ceiling2(%ld, %ld) = %ld, ceiling2(%ld, %ld) = %ld\n", li, li, lir1, li + 2h, li, lir2, -li - 2h, li, lir3 ); + } // for + printf( "\n" ); + + printf( "unsigned long int\n" ); + uli = 0; + ulir1 = ceiling2( uli, uli ), ulir2 = ceiling2( uli + 2hh, uli ), ulir3 = ceiling2( -uli - 2hh, uli ); + printf( "ceiling2(%lu, %lu) = %lu, ceiling2(%lu, %lu) = %lu, ceiling2(%lu, %lu) = %lu\n", uli, uli, ulir1, uli + 2h, uli, ulir2, -uli - 2h, uli, ulir3 ); + for ( uli = 1; uli != 0; uli <<= 1 ) { + ulir1 = ceiling2( uli, uli ); ulir2 = ceiling2( uli + 2hh, uli ); ulir3 = ceiling2( -uli - 2hh, uli ); + printf( "ceiling2(%lu, %lu) = %lu, ceiling2(%lu, %lu) = %lu, ceiling2(%lu, %lu) = %lu\n", uli, uli, ulir1, uli + 2h, uli, ulir2, -uli - 2h, uli, ulir3 ); + } // for + printf( "\n" ); + + printf( "long long int\n" ); + lli = 0; + llir1 = ceiling2( lli, lli ), llir2 = ceiling2( lli + 2hh, lli ), llir3 = ceiling2( -lli - 2hh, lli ); + printf( "ceiling2(%lld, %lld) = %lld, ceiling2(%lld, %lld) = %lld, ceiling2(%lld, %lld) = %lld\n", lli, lli, llir1, lli + 2h, lli, llir2, -lli - 2h, lli, llir3 ); + for ( lli = 1; lli != 0; lli <<= 1 ) { + llir1 = ceiling2( lli, lli ); llir2 = ceiling2( lli + 2hh, lli ); llir3 = ceiling2( -lli - 2hh, lli ); + printf( "ceiling2(%lld, %lld) = %lld, ceiling2(%lld, %lld) = %lld, ceiling2(%lld, %lld) = %lld\n", lli, lli, llir1, lli + 2h, lli, llir2, -lli - 2h, lli, llir3 ); + } // for + printf( "\n" ); + + printf( "unsigned long long int\n" ); + ulli = 0; + ullir1 = ceiling2( ulli, ulli ), ullir2 = ceiling2( ulli + 2hh, ulli ), ullir3 = ceiling2( -ulli - 2hh, ulli ); + printf( "ceiling2(%llu, %llu) = %llu, ceiling2(%llu, %llu) = %llu, ceiling2(%llu, %llu) = %llu\n", ulli, ulli, ullir1, ulli + 2h, ulli, ullir2, -ulli - 2h, ulli, ullir3 ); + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + ullir1 = ceiling2( ulli, ulli ); ullir2 = ceiling2( ulli + 2hh, ulli ); ullir3 = ceiling2( -ulli - 2hh, ulli ); + printf( "ceiling2(%llu, %llu) = %llu, ceiling2(%llu, %llu) = %llu, ceiling2(%llu, %llu) = %llu\n", ulli, ulli, ullir1, ulli + 2h, ulli, ullir2, -ulli - 2h, ulli, ullir3 ); + } // for + printf( "\n" ); +#endif // 0 + //============================================================ +#if 1 + sout | nl | "ceiling" | nl | nl; + + printf( "signed char\n" ); + for ( sc = 1; sc != 0; sc <<= 1 ) { + scr1 = ceiling( sc, sc ); scr2 = ceiling( sc + 2hh, sc ); scr3 = ceiling( -sc - 2hh, sc ); + printf( "ceiling(%hhd, %hhd) = %hhd, ceiling(%hhd, %hhd) = %hhd, ceiling(%hhd, %hhd) = %hhd\n", sc, sc, scr1, sc + 2hh, sc, scr2, -sc - 2hh, sc, scr3 ); + } // for + printf( "\n" ); + + printf( "unsigned char\n" ); + for ( uc = 1; uc != 0; uc <<= 1 ) { + ucr1 = ceiling( uc, uc ); ucr2 = ceiling( uc + 2hh, uc ); ucr3 = ceiling( -uc - 2hh, uc ); + printf( "ceiling(%hhu, %hhu) = %hhu, ceiling(%hhu, %hhu) = %hhu, ceiling(%hhu, %hhu) = %hhu\n", uc, uc, ucr1, uc + 2uhh, uc, ucr2, -uc - 2uhh, uc, ucr3 ); + } // for + printf( "\n" ); + + printf( "short int\n" ); + for ( si = 1; si != 0; si <<= 1 ) { + sir1 = ceiling( si, si ); sir2 = ceiling( si + 2hh, si ); sir3 = ceiling( -si - 2hh, si ); + printf( "ceiling(%hd, %hd) = %hd, ceiling(%hd, %hd) = %hd, ceiling(%hd, %hd) = %hd\n", si, si, sir1, si + 2h, si, sir2, -si - 2h, si, sir3 ); + } // for + printf( "\n" ); + + printf( "unsigned short int\n" ); + for ( usi = 1; usi != 0; usi <<= 1 ) { + usir1 = ceiling( usi, usi ); usir2 = ceiling( usi + 2hh, usi ); usir3 = ceiling( -usi - 2hh, usi ); + printf( "ceiling(%hu, %hu) = %hu, ceiling(%hu, %hu) = %hu, ceiling(%hu, %hu) = %hu\n", usi, usi, usir1, usi + 2uh, usi, usir2, -usi - 2uh, usi, usir3 ); + } // for + printf( "\n" ); + + printf( "int\n" ); + for ( i = 1; i != 0; i <<= 1 ) { + ir1 = ceiling( i, i ); ir2 = ceiling( i + 2hh, i ); ir3 = ceiling( -i - 2hh, i ); + printf( "ceiling(%d, %d) = %d, ceiling(%d, %d) = %d, ceiling(%d, %d) = %d\n", i, i, ir1, i + 2h, i, ir2, -i - 2h, i, ir3 ); + } // for + printf( "\n" ); + + printf( "unsigned int\n" ); + for ( ui = 1; ui != 0; ui <<= 1 ) { + uir1 = ceiling( ui, ui ); uir2 = ceiling( ui + 2hh, ui ); uir3 = ceiling( -ui - 2hh, ui ); + printf( "ceiling(%u, %u) = %u, ceiling(%u, %u) = %u, ceiling(%u, %u) = %u\n", ui, ui, uir1, ui + 2h, ui, uir2, -ui - 2h, ui, uir3 ); + } // for + printf( "\n" ); + + printf( "long int\n" ); + for ( li = 1; li != 0; li <<= 1 ) { + lir1 = ceiling( li, li ); lir2 = ceiling( li + 2hh, li ); lir3 = ceiling( -li - 2hh, li ); + printf( "ceiling(%ld, %ld) = %ld, ceiling(%ld, %ld) = %ld, ceiling(%ld, %ld) = %ld\n", li, li, lir1, li + 2h, li, lir2, -li - 2h, li, lir3 ); + } // for + printf( "\n" ); + + printf( "unsigned long int\n" ); + for ( uli = 1; uli != 0; uli <<= 1 ) { + ulir1 = ceiling( uli, uli ); ulir2 = ceiling( uli + 2hh, uli ); ulir3 = ceiling( -uli - 2hh, uli ); + printf( "ceiling(%lu, %lu) = %lu, ceiling(%lu, %lu) = %lu, ceiling(%lu, %lu) = %lu\n", uli, uli, ulir1, uli + 2h, uli, ulir2, -uli - 2h, uli, ulir3 ); + } // for + printf( "\n" ); + + printf( "long long int\n" ); + for ( lli = 1; lli != 0; lli <<= 1 ) { + llir1 = ceiling( lli, lli ); llir2 = ceiling( lli + 2hh, lli ); llir3 = ceiling( -lli - 2hh, lli ); + printf( "ceiling(%lld, %lld) = %lld, ceiling(%lld, %lld) = %lld, ceiling(%lld, %lld) = %lld\n", lli, lli, llir1, lli + 2h, lli, llir2, -lli - 2h, lli, llir3 ); + } // for + printf( "\n" ); + + printf( "unsigned long long int\n" ); + for ( ulli = 1; ulli != 0; ulli <<= 1 ) { + ullir1 = ceiling( ulli, ulli ); ullir2 = ceiling( ulli + 2hh, ulli ); ullir3 = ceiling( -ulli - 2hh, ulli ); + printf( "ceiling(%llu, %llu) = %llu, ceiling(%llu, %llu) = %llu, ceiling(%llu, %llu) = %llu\n", ulli, ulli, ullir1, ulli + 2h, ulli, ullir2, -ulli - 2h, ulli, ullir3 ); + } // for + printf( "\n" ); +#endif // 0 +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa bitmanip3.cfa" // +// End: // Index: tests/concurrent/.expect/monitor.txt =================================================================== --- tests/concurrent/.expect/monitor.txt (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/concurrent/.expect/monitor.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,1 +1,1 @@ -4000000 +3000000 Index: tests/concurrent/monitor.cfa =================================================================== --- tests/concurrent/monitor.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/concurrent/monitor.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -29,5 +29,5 @@ void main( MyThread & this ) { - for(int i = 0; i < 1_000_000; i++) { + for(int i = 0; i < 750_000; i++) { increment( global ); } Index: tests/errors/.expect/completeType.txt =================================================================== --- tests/errors/.expect/completeType.txt (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/errors/.expect/completeType.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -27,5 +27,5 @@ void ) - Environment:( _85_4_DT ) -> instance of struct A with body 0 (no widening) + Environment: -> instance of struct A with body 0 (no widening) @@ -50,5 +50,5 @@ void ) - Environment:( _85_4_DT ) -> instance of struct B with body 1 (no widening) + Environment: -> instance of struct B with body 1 (no widening) @@ -127,5 +127,5 @@ void ) - Environment:( _104_0_T ) -> instance of type T (not function type) (no widening) + Environment: -> instance of type T (not function type) (no widening) Could not satisfy assertion: Index: tests/exceptions/.expect/data-except.txt =================================================================== --- tests/exceptions/.expect/data-except.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/exceptions/.expect/data-except.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,4 @@ +paired(3, 13) +paired(3, 13) +paired(3, 13) +paired(4, 13) Index: tests/exceptions/.expect/interact.txt =================================================================== --- tests/exceptions/.expect/interact.txt (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/exceptions/.expect/interact.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -14,2 +14,8 @@ resumption catch, will terminate inner termination catch + +throwing resume moon +resumption moon catch, will terminate +termination catch +throwing resume star +resumption star catch Index: tests/exceptions/.expect/resume.txt =================================================================== --- tests/exceptions/.expect/resume.txt (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/exceptions/.expect/resume.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -25,2 +25,6 @@ caught second exception recaught first exception + +inner catch +inner catch +outer catch Index: tests/exceptions/.expect/terminate.txt =================================================================== --- tests/exceptions/.expect/terminate.txt (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/exceptions/.expect/terminate.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -24,2 +24,5 @@ caught second exception recaught first exception + +inner catch +outer catch Index: tests/exceptions/conditional.cfa =================================================================== --- tests/exceptions/conditional.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/exceptions/conditional.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -4,8 +4,8 @@ // up the non-trivial exception is reasonable to do. -#include "except-mac.hfa" +#include #include -DECLARE_EXCEPT(num_error, BASE_EXCEPT, +VTABLE_DECLARATION(num_error)( int (*code)(num_error *this); ); @@ -36,7 +36,4 @@ this.num = other.num; } -void copy(num_error * this, num_error * other) { - *this = *other; -} void ^?{}(num_error & this) { if( this.msg ) free( this.msg ); @@ -46,6 +43,7 @@ } -VTABLE_INSTANCE(num_error, BASE_EXCEPT, copy, ^?{}, - num_error_msg, num_error_code +VTABLE_INSTANCE(num_error)( + num_error_msg, + num_error_code, ); @@ -58,5 +56,5 @@ try { - THROW(&exc); + throw &exc; } catch (num_error * error ; 3 == error->virtual_table->code( error )) { caught_num_error(3, error); @@ -66,5 +64,5 @@ try { - THROW_RESUME(&exc); + throwResume &exc; } catchResume (num_error * error ; 3 == error->virtual_table->code( error )) { caught_num_error(3, error); Index: tests/exceptions/data-except.cfa =================================================================== --- tests/exceptions/data-except.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/exceptions/data-except.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,46 @@ +// Test exceptions that add data but no functionality. + +#include + +DATA_EXCEPTION(paired)( + int first; + int second; +); + +void ?{}(paired & this, int first, int second) { + VTABLE_INIT(this, paired); + this.first = first; + this.second = second; +} + +const char * paired_msg(paired * this) { + return "paired"; +} + +VTABLE_INSTANCE(paired)(paired_msg); + +void throwPaired(int first, int second) { + paired exc = {first, second}; +} + +int main(int argc, char * argv[]) { + paired except = {3, 13}; + + try { + throw &except; + } catch (paired * exc) { + printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second); + ++exc->first; + } + + printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second); + + try { + throwResume &except; + } catchResume (paired * exc) { + printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second); + ++exc->first; + } + + printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second); +} Index: sts/exceptions/except-mac.hfa =================================================================== --- tests/exceptions/except-mac.hfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ (revision ) @@ -1,81 +1,0 @@ -// Macros to try and make declaring and using exceptions easier -// No, these are not part of the language, they replace the virtual system. - -// Internal use: -#define GLUE2(left, right) left##right -#define GLUE3(left, middle, right) left##middle##right - -// The fully qualified name of the base exception type: -#define BASE_EXCEPT __cfaehm_base_exception_t - -// Get the name of the vtable type and vtable instance for an exception type: -#define TABLE(name) GLUE2(name,_vtable) -#define INSTANCE(name) GLUE3(_,name,_vtable_instance) - -// Throws and the bit of overhead: -#define THROW(expr) throw ((BASE_EXCEPT *)(expr)) -#define THROW_RESUME(expr) throwResume ((BASE_EXCEPT *)(expr)) - - - -// The following macros are for defining your own new exception types. - -// Declare vtable and forward declare the exception type and vtable instance. -// This should start a new exception declaration. -// ... argument is the additional vtable fields. -#define DECLARE_EXCEPT(except_name,parent_name,...) \ -struct except_name; \ -struct TABLE(except_name) { \ - struct TABLE(parent_name) const * parent; \ - size_t size; \ - void (*copy)(except_name *this, except_name * other); \ - void (*free)(except_name &this); \ - const char * (*msg)(except_name *this); \ - __VA_ARGS__ \ -}; \ -extern TABLE(except_name) INSTANCE(except_name) - -// The first field of the exception structure should be created with this. -#define VTABLE_FIELD(except_name) \ -struct TABLE(except_name) const * virtual_table - -// In each constructor the vtable must be initialized. -#define VTABLE_INIT(this_name,except_name) \ -this_name.virtual_table = &INSTANCE(except_name) - -// Declare the vtable instance. This should end an exception declaration. -// ... argument is the remaining vtable field values. -#define VTABLE_INSTANCE(except_name,parent_name,copy,free,msg,...) \ -TABLE(except_name) INSTANCE(except_name) @= { \ - &INSTANCE(parent_name), sizeof(except_name), \ - copy, free, msg, ## __VA_ARGS__ \ -} - -// Same, but used declarators for arguments. -#define VTABLE_INSTANCE_KEY(except_name,parent_name,copy,free,msg,...) \ -TABLE(except_name) INSTANCE(except_name) @= { \ - .parent : &INSTANCE(parent_name), .size : sizeof(except_name), \ - .copy : copy, .free : free, .msg : msg, ## __VA_ARGS__ \ -} - - - -// Declare a trivial exception, one that adds no features: -#define _TRIVIAL_EXCEPTION(name, parent_name, ...) \ -DECLARE_EXCEPT(name,parent_name,); \ -struct name { \ - VTABLE_FIELD(name); \ -}; \ -const char * GLUE2(name,_msg)(name * this) { \ - return #name; \ -} \ -void GLUE2(name,_copy)(name * this, name * other) { \ - this->virtual_table = other->virtual_table; \ -} \ -void ?{}(name & this) { \ - VTABLE_INIT(this,name); \ -} \ -VTABLE_INSTANCE(name,parent_name,GLUE2(name,_copy),^?{},GLUE2(name,_msg),) - -// TRIVIAL_EXCEPTION(name_of_exception, [parent_exception]) -#define TRIVIAL_EXCEPTION(...) _TRIVIAL_EXCEPTION(__VA_ARGS__,BASE_EXCEPT,) Index: tests/exceptions/finally.cfa =================================================================== --- tests/exceptions/finally.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/exceptions/finally.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,5 +1,5 @@ // Finally Clause Tests -#include "except-mac.hfa" +#include #include "except-io.hfa" @@ -12,5 +12,5 @@ try { printf("termination throw\n"); - THROW(&exc); + throw &exc; } finally { loud_exit a = "termination inner finally"; @@ -28,5 +28,5 @@ try { printf("resumption throw\n"); - THROW_RESUME(&exc); + throwResume &exc; } finally { loud_exit a = "resumption inner finally"; Index: tests/exceptions/interact.cfa =================================================================== --- tests/exceptions/interact.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/exceptions/interact.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,5 +1,5 @@ // Testing Interactions Between Termination and Resumption -#include "except-mac.hfa" +#include #include "except-io.hfa" @@ -10,5 +10,5 @@ // Resume falls back to terminate. try { - THROW_RESUME(&(star){}); + throwResume &(star){}; } catch (star *) { printf("caught as termination\n"); @@ -17,5 +17,5 @@ try { loud_region a = "try block with resume throw"; - THROW_RESUME(&(star){}); + throwResume &(star){}; } catch (star *) { printf("caught as termination\n"); @@ -29,5 +29,5 @@ try { try { - THROW(&(star){}); + throw &(star){}; } catchResume (star *) { printf("resume catch on terminate\n"); @@ -43,5 +43,5 @@ try { try { - THROW_RESUME(&(star){}); + throwResume &(star){}; } catch (star *) { printf("terminate catch on resume\n"); @@ -58,5 +58,5 @@ try { try { - THROW(&(star){}); + throw &(star){}; } catchResume (star *) { printf("inner resume catch (error)\n"); @@ -64,5 +64,5 @@ } catch (star * error) { printf("termination catch, will resume\n"); - THROW_RESUME(error); + throwResume error; } } catchResume (star *) { @@ -75,5 +75,5 @@ try { try { - THROW_RESUME(&(star){}); + throwResume &(star){}; } catch (star *) { printf("inner termination catch\n"); @@ -81,10 +81,9 @@ } catchResume (star * error) { printf("resumption catch, will terminate\n"); - THROW(error); + throw error; } } catch (star *) { printf("outer terminate catch (error)\n"); } -#if 0 printf("\n"); @@ -95,10 +94,10 @@ try { printf("throwing resume moon\n"); - THROW_RESUME(&(moon){}); + throwResume &(moon){}; } catch (star *) { printf("termination catch\n"); } printf("throwing resume star\n"); - THROW_RESUME(&(star){}); + throwResume &(star){}; } catchResume (star *) { printf("resumption star catch\n"); @@ -106,9 +105,8 @@ } catchResume (moon *) { printf("resumption moon catch, will terminate\n"); - THROW(&(star){}); + throw &(star){}; } } catchResume (star *) { printf("outermost catch (error)\n"); } -#endif } Index: tests/exceptions/resume.cfa =================================================================== --- tests/exceptions/resume.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/exceptions/resume.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,5 +1,5 @@ // Resumption Exception Tests -#include "except-mac.hfa" +#include #include "except-io.hfa" @@ -14,5 +14,5 @@ loud_exit a = "simple try clause"; printf("simple throw\n"); - THROW_RESUME(&(zen){}); + throwResume &(zen){}; printf("end of try clause\n"); } catchResume (zen * error) { @@ -25,5 +25,5 @@ try { printf("throwing child exception\n"); - THROW_RESUME(&(moment_of){}); + throwResume &(moment_of){}; } catchResume (zen *) { printf("inner parent match\n"); @@ -36,5 +36,5 @@ try { try { - THROW_RESUME(&(yin){}); + throwResume &(yin){}; } catchResume (zen *) { printf("caught yin as zen\n"); @@ -52,5 +52,5 @@ loud_exit a = "rethrow inner try"; printf("rethrow inner try\n"); - THROW_RESUME(&(zen){}); + throwResume &(zen){}; } catchResume (zen *) { loud_exit a = "rethrowing catch clause"; @@ -67,8 +67,8 @@ try { try { - THROW_RESUME(&(yin){}); + throwResume &(yin){}; } catchResume (yin *) { printf("caught yin, will throw yang\n"); - THROW_RESUME(&(yang){}); + throwResume &(yang){}; } catchResume (yang *) { printf("caught exception from same try\n"); @@ -83,10 +83,10 @@ try { printf("throwing first exception\n"); - THROW_RESUME(&(yin){}); + throwResume &(yin){}; } catchResume (yin *) { printf("caught first exception\n"); try { printf("throwing second exception\n"); - THROW_RESUME(&(yang){}); + throwResume &(yang){}; } catchResume (yang *) { printf("caught second exception\n"); @@ -99,3 +99,17 @@ printf("caught second exception (bad location)\n"); } + printf("\n"); + + // Check successive operations. + try { + try { + throwResume &(zen){}; + throwResume &(zen){}; + } catchResume (zen *) { + printf("inner catch\n"); + } + throwResume &(zen){}; + } catchResume (zen *) { + printf("outer catch\n"); + } } Index: tests/exceptions/terminate.cfa =================================================================== --- tests/exceptions/terminate.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/exceptions/terminate.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -1,5 +1,5 @@ // Termination Exception Tests -#include "except-mac.hfa" +#include #include "except-io.hfa" @@ -14,5 +14,5 @@ loud_exit a = "simple try clause"; printf("simple throw\n"); - THROW(&(zen){}); + throw &(zen){}; printf("end of try clause\n"); } catch (zen * error) { @@ -25,5 +25,5 @@ try { printf("throwing child exception\n"); - THROW(&(moment_of){}); + throw &(moment_of){}; } catch (zen *) { printf("inner parent match\n"); @@ -36,5 +36,5 @@ try { try { - THROW(&(yin){}); + throw &(yin){}; } catch (zen *) { printf("caught yin as zen\n"); @@ -52,5 +52,5 @@ loud_exit a = "rethrow inner try"; printf("rethrow inner try\n"); - THROW(&(zen){}); + throw &(zen){}; } catch (zen *) { loud_exit a = "rethrowing catch clause"; @@ -67,8 +67,8 @@ try { try { - THROW(&(yin){}); + throw &(yin){}; } catch (yin *) { printf("caught yin, will throw yang\n"); - THROW(&(yang){}); + throw &(yang){}; } catch (yang *) { printf("caught exception from same try\n"); @@ -83,10 +83,10 @@ try { printf("throwing first exception\n"); - THROW(&(yin){}); + throw &(yin){}; } catch (yin *) { printf("caught first exception\n"); try { printf("throwing second exception\n"); - THROW(&(yang){}); + throw &(yang){}; } catch (yang *) { printf("caught second exception\n"); @@ -99,3 +99,17 @@ printf("caught second exception (bad location)\n"); } + printf("\n"); + + // Check successive operations. + try { + try { + throw &(zen){}; + throw &(zen){}; + } catch (zen *) { + printf("inner catch\n"); + } + throw &(zen){}; + } catch (zen *) { + printf("outer catch\n"); + } } Index: tests/list/.expect/dlist-insert-remove.txt =================================================================== --- tests/list/.expect/dlist-insert-remove.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/list/.expect/dlist-insert-remove.txt (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1465 @@ +~~~~~~~~~~~~~~~~~ Headless List Tests - insert_after ~~~~~~~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 1-i: Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by MINE after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +==== fred by YOURS after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 2-i. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by MINE after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 3-i. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== mary after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- + +~~~~~~~~~~~~~~~~ Headless List Tests - insert_before ~~~~~~~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 1-ii: Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by MINE after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +==== fred by YOURS after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 2-ii. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by MINE after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 3-ii. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== mary after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- + +~~~~~~~~~~~~~~~~~ Headed List Tests - insert_first ~~~~~~~~~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 4-i: Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by MINE after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +==== fred by YOURS after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 5-i: Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by MINE after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 6-i. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== mary after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- + +~~~~~~~~~~~~~~~~~ Headed List Tests - insert_last ~~~~~~~~~~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 4-ii: Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by MINE after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +==== fred by YOURS after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 5-ii: Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by MINE after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 6-ii. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== mary after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- + +~~~~~~~~~~~ Element ops on Headed List Tests: after, last ~~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 7-i. Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +==== fred by YOURS after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 8-i. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 9-i. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- + +~~~~~~~~~~ Element ops on Headed List Tests: before, first ~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 7-ii. Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +==== fred by YOURS after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 8-ii. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE after +3.14 +- +3.14 +- +0.5 +- +0.5 +- +==== fred by YOURS after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 9-ii. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary after +3.14 +0.5 +- +3.14 +- +0.5 +- +0.5 +3.14 +- + +~~~~~~~~~~ Element removal tests on Headless List: mid ~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 10-i. Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +1.7 +- +==== fred by YOURS after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +2.7 +- +2.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 11-i. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS after +1.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +1.7 +- +==== fred by YOURS after +2.7 +- +2.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 12-i. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== mary after +1.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +1.7 +- +==== mary after +2.7 +- +2.7 +- +- +- + +~~~~~~~~~~ Element removal tests on Headless List: at first ~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 10-ii. Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +2.7 +3.7 +- +2.7 +- +3.7 +- +3.7 +2.7 +- +==== fred by YOURS after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +- +1.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 11-ii. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS after +2.7 +3.7 +- +2.7 +- +3.7 +- +3.7 +2.7 +- +==== fred by YOURS after +1.7 +- +1.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 12-ii. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== mary after +2.7 +3.7 +- +2.7 +- +3.7 +- +3.7 +2.7 +- +==== mary after +1.7 +- +1.7 +- +- +- + +~~~~~~~~~~ Element removal tests on Headless List: at last ~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 10-iii. Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +2.7 +- +1.7 +- +2.7 +- +2.7 +1.7 +- +==== fred by YOURS after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +3.7 +- +3.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 11-iii. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS after +1.7 +2.7 +- +1.7 +- +2.7 +- +2.7 +1.7 +- +==== fred by YOURS after +3.7 +- +3.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 12-iii. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== mary after +1.7 +2.7 +- +1.7 +- +2.7 +- +2.7 +1.7 +- +==== mary after +3.7 +- +3.7 +- +- +- + +~~~~~~~~~~ Element removal tests on Headed List: at first ~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 13-i. Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +2.7 +3.7 +- +2.7 +- +3.7 +- +3.7 +2.7 +- +==== fred by YOURS after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +- +1.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 14-i. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS after +2.7 +3.7 +- +2.7 +- +3.7 +- +3.7 +2.7 +- +==== fred by YOURS after +1.7 +- +1.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 15-i. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== mary after +2.7 +3.7 +- +2.7 +- +3.7 +- +3.7 +2.7 +- +==== mary after +1.7 +- +1.7 +- +- +- + +~~~~~~~~~~ Element removal tests on Headed List: at last ~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 13-ii. Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +2.7 +- +1.7 +- +2.7 +- +2.7 +1.7 +- +==== fred by YOURS after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +3.7 +- +3.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 14-ii. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by MINE after +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== fred by YOURS after +1.7 +2.7 +- +1.7 +- +2.7 +- +2.7 +1.7 +- +==== fred by YOURS after +3.7 +- +3.7 +- +- +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 15-ii. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +1.7 +2.7 +3.7 +- +1.7 +- +3.7 +- +3.7 +2.7 +1.7 +- +==== mary after +1.7 +2.7 +- +1.7 +- +2.7 +- +2.7 +1.7 +- +==== mary after +3.7 +- +3.7 +- +- +- + +~~~~~~~~~~ Element removal tests on Headed List: of sole ~~~~~~~~~~ + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 13-iii. Modifying Freds on MINE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +0.7 +- +0.7 +- +0.7 +- +0.7 +- +==== fred by YOURS before +0.7 +- +0.7 +- +0.7 +- +0.7 +- +==== fred by YOURS after +0.7 +- +0.7 +- +0.7 +- +0.7 +- +==== fred by MINE after +0.7 +- +0.7 +- +- +- +==== fred by MINE after +0.7 +- +0.7 +- +0.7 +- +0.7 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 14-iii. Modifying Freds on YOURS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== fred by MINE before +0.7 +- +0.7 +- +0.7 +- +0.7 +- +==== fred by YOURS before +0.7 +- +0.7 +- +0.7 +- +0.7 +- +==== fred by YOURS after +0.7 +- +0.7 +- +0.7 +- +0.7 +- +==== fred by YOURS after +0.7 +- +0.7 +- +- +- +==== fred by YOURS after +0.7 +- +0.7 +- +0.7 +- +0.7 +- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Test 15-iii. Modifying Maries +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +==== mary before +0.7 +- +0.7 +- +0.7 +- +0.7 +- +==== mary after +0.7 +- +0.7 +- +- +- +==== mary after +0.7 +- +0.7 +- +0.7 +- +0.7 +- Index: tests/list/dlist-insert-remove.cfa =================================================================== --- tests/list/dlist-insert-remove.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/list/dlist-insert-remove.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,1425 @@ +#include +#include +#include + +// Section 1: replaced by above include list.hfa + + +//////////////////////////////////////////////////////////// +// +// Section 2 +// +// Structure definitions +// +// Example of declaration-side user code +// +//////////////////////////////////////////////////////////// + +// a fred belongs to two doubly-linked lists: mine and yours +struct fred { + float adatum; + DLISTED_MGD_EXPL_IN(fred, mine) + DLISTED_MGD_EXPL_IN(fred, yours) +}; + +DLISTED_MGD_EXPL_OUT(fred, mine) +DLISTED_MGD_EXPL_OUT(fred, yours) + +void ?{}(fred &this, float adatum) { + (this.adatum){adatum}; +} + +// a mary belongs to just one doubly-linked list: hers +struct mary { + float anotherdatum; + DLISTED_MGD_IMPL_IN(mary) +}; + +DLISTED_MGD_IMPL_OUT(mary) + +void ?{}(mary &this, float anotherdatum) { + (this.anotherdatum){anotherdatum}; +} + +//////////////////////////////////////////////////////////// +// +// Section 3 +// +// Test helpers to traverse and print lists. +// +// These consume framework-provided accessor functions and +// do not modify their parameter lists. +// +//////////////////////////////////////////////////////////// + +void printMyFredsFwd(fred &f) { + while (&f != 0p) { + sout | f.adatum; + &f = &f`in_mine`next; + } +} + +void printMyFredsRev(fred &f) { + while (&f != 0p) { + sout | f.adatum; + &f = &f`in_mine`prev; + } +} + +void printMyFreddies(fred &f1, fred &f2, int isBefore) { + if (isBefore) { + sout | "==== fred by MINE before "; + } else { + sout | "==== fred by MINE after "; + } + printMyFredsFwd(f1); sout | '-'; + printMyFredsRev(f1); sout | '-'; + printMyFredsFwd(f2); sout | '-'; + printMyFredsRev(f2); sout | '-'; +} + +void printYourFredsFwd(fred &f) { + while (&f != 0p) { + sout | f.adatum; + &f = &f`in_yours`next; + } +} + +void printYourFredsRev(fred &f) { + while (&f != 0p) { + sout | f.adatum; + &f = &f`in_yours`prev; + } +} + +void printYourFreddies(fred &f1, fred &f2, int isBefore) { + if (isBefore) { + sout | "==== fred by YOURS before "; + } else { + sout | "==== fred by YOURS after "; + } + printYourFredsFwd(f1); sout | '-'; + printYourFredsRev(f1); sout | '-'; + printYourFredsFwd(f2); sout | '-'; + printYourFredsRev(f2); sout | '-'; +} + +void printMariesFwd(mary &m) { + while (&m != 0p) { + sout | m.anotherdatum; + &m = &m`next; + } +} + +void printMariesRev(mary &m) { + while (&m != 0p) { + sout | m.anotherdatum; + &m = &m`prev; + } +} + +void printMariatheotokos(mary &m1, mary &m2, int isBefore) { + if (isBefore) { + sout | "==== mary before "; + } else { + sout | "==== mary after "; + } + printMariesFwd(m1); sout | '-'; + printMariesRev(m1); sout | '-'; + printMariesFwd(m2); sout | '-'; + printMariesRev(m2); sout | '-'; +} + +//////////////////////////////////////////////////////////// +// +// Section 4a.i +// +// Test cases of insert_after on headless list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +// All three tests exercise the case of merging two singleton lists into (their respective +// positions in) one common list of two elements. + +// Note that the factoring of sect 4 (vs 3 and 5) keeps section 4 free of strings and IO, +// and so keeps its assembly easy to inspect. + +// Throughout all the 4s, all the print functions called from these tests print: +// - from list position #1 moving forward (a) +// - from list position #1 moving backward (b) +// - from list position #2 moving forward (c) +// - from list position #2 moving backward (d) +// The expected-output comments are in form a;b;c;d where a::=num,num,num + +void test__insertafter_singleton_on_singleton__fred_mine () { + fred f1 = {3.14}; + fred f2 = {0.5}; + + printMyFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + printYourFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_after(f1`in_mine, f2); + + printMyFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + printYourFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) +} + +void test__insertafter_singleton_on_singleton__fred_yours () { + fred f1 = {3.14}; + fred f2 = {0.5}; + + printMyFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + printYourFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_after(f1`in_yours, f2); + + printMyFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) + printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) +} + +void test__insertafter_singleton_on_singleton__mary () { + mary m1 = {3.14}; + mary m2 = {0.5}; + + printMariatheotokos(m1, m2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_after(m1, m2); + + printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) +} + +//////////////////////////////////////////////////////////// +// +// Section 4a.ii +// +// Test cases of insert_before on headless list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +void test__insertbefore_singleton_on_singleton__fred_mine () { + fred f1 = {3.14}; + fred f2 = {0.5}; + + printMyFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + printYourFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_before(f2`in_mine, f1); + + printMyFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + printYourFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) +} + +void test__insertbefore_singleton_on_singleton__fred_yours () { + fred f1 = {3.14}; + fred f2 = {0.5}; + + printMyFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + printYourFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_before(f2`in_yours, f1); + + printMyFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) + printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) +} + +void test__insertbefore_singleton_on_singleton__mary () { + mary m1 = {3.14}; + mary m2 = {0.5}; + + printMariatheotokos(m1, m2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_before(m2, m1); + + printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) +} + +//////////////////////////////////////////////////////////// +// +// Section 4b.i +// +// Test cases of insert_first (necessarily headed list) +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +// All three tests exercise the case of creating an empty container and +// adding two items to it. + +void test__insertfirst_two_on_empty__fred_mine() { + + fred f1 = {3.14}; + fred f2 = {0.5}; + + dlist(fred_in_mine, fred) lf; + + verify(validate(lf)); + + printMyFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + printYourFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_first(lf, f2); + insert_first(lf, f1); + + verify(validate(lf)); + + printMyFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + printYourFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) +} + +void test__insertfirst_two_on_empty__fred_yours() { + + fred f1 = {3.14}; + fred f2 = {0.5}; + + dlist(fred_in_yours, fred) lf; + + verify(validate(lf)); + + printMyFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + printYourFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_first(lf, f2); + insert_first(lf, f1); + + verify(validate(lf)); + + printMyFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) + printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) +} + +void test__insertfirst_two_on_empty__mary() { + + mary m1 = {3.14}; + mary m2 = {0.5}; + + dlist(mary, mary) lm; + + verify(validate(lm)); + printMariatheotokos(m1, m2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_first(lm, m2); + insert_first(lm, m1); + + printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + verify(validate(lm)); +} + +//////////////////////////////////////////////////////////// +// +// Section 4b.ii +// +// Test cases of insert_last (necessarily headed list) +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +void test__insertlast_two_on_empty__fred_mine() { + + fred f1 = {3.14}; + fred f2 = {0.5}; + + dlist(fred_in_mine, fred) lf; + + verify(validate(lf)); + + printMyFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + printYourFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_last(lf, f1); + insert_last(lf, f2); + + verify(validate(lf)); + + printMyFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + printYourFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) +} + +void test__insertlast_two_on_empty__fred_yours() { + + fred f1 = {3.14}; + fred f2 = {0.5}; + + dlist(fred_in_yours, fred) lf; + + verify(validate(lf)); + + printMyFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + printYourFreddies(f1, f2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_last(lf, f1); + insert_last(lf, f2); + + verify(validate(lf)); + + printMyFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) + printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) +} + +void test__insertlast_two_on_empty__mary() { + + mary m1 = {3.14}; + mary m2 = {0.5}; + + dlist(mary, mary) lm; + + verify(validate(lm)); + printMariatheotokos(m1, m2, 1); // 3.14; 3.14; 0.5; 0.5 + + insert_last(lm, m1); + insert_last(lm, m2); + + verify(validate(lm)); + printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) +} + +//////////////////////////////////////////////////////////// +// +// Section 4c.i +// +// Test cases of insert_after on headed list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +void test__insertafter_after_last__fred_mine() { + + fred f1 = {3.14}; + fred f2 = {0.5}; + + dlist(fred_in_mine, fred) lf; + + assert(& lf`first == 0p); + assert(& lf`last == 0p); + + insert_first(lf, f1); + + assert(& lf`first == & f1); + assert(& lf`last == & f1); + + verify(validate(lf)); + + insert_after(f1`in_mine, f2); + + verify(validate(lf)); + + printMyFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + printYourFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) + + assert(& lf`first == & f1); + assert(& lf`last == & f2); +} + +void test__insertafter_after_last__fred_yours() { + + fred f1 = {3.14}; + fred f2 = {0.5}; + + dlist(fred_in_yours, fred) lf; + + assert(& lf`first == 0p); + assert(& lf`last == 0p); + + insert_first(lf, f1); + + assert(& lf`first == & f1); + assert(& lf`last == & f1); + + verify(validate(lf)); + + insert_after(f1`in_yours, f2); + + verify(validate(lf)); + + printMyFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) + printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + + assert(& lf`first == & f1); + assert(& lf`last == & f2); +} + +void test__insertafter_after_last__mary() { + + mary m1 = {3.14}; + mary m2 = {0.5}; + + dlist(mary, mary) lm; + + assert(& lm`first == 0p); + assert(& lm`last == 0p); + + insert_first(lm, m1); + + assert(& lm`first == & m1); + assert(& lm`last == & m1); + + verify(validate(lm)); + + insert_after(m1, m2); + + verify(validate(lm)); + + printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + + assert(& lm`first == & m1); + assert(& lm`last == & m2); +} + +//////////////////////////////////////////////////////////// +// +// Section 4c.ii +// +// Test cases of insert_before on headed list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +void test__insertbefore_before_first__fred_mine() { + + fred f1 = {3.14}; + fred f2 = {0.5}; + + dlist(fred_in_mine, fred) lf; + + assert(& lf`first == 0p); + assert(& lf`last == 0p); + + insert_last(lf, f2); + + assert(& lf`first == & f2); + assert(& lf`last == & f2); + + verify(validate(lf)); + + insert_before(f2`in_mine, f1); + + verify(validate(lf)); + + printMyFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + printYourFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) + + assert(& lf`first == & f1); + assert(& lf`last == & f2); +} + +void test__insertbefore_before_first__fred_yours() { + + fred f1 = {3.14}; + fred f2 = {0.5}; + + dlist(fred_in_yours, fred) lf; + + assert(& lf`first == 0p); + assert(& lf`last == 0p); + + insert_last(lf, f2); + + assert(& lf`first == & f2); + assert(& lf`last == & f2); + + verify(validate(lf)); + + insert_before(f2`in_yours, f1); + + verify(validate(lf)); + + printMyFreddies(f1, f2, 0); // 3.14; 3.14; 0.5; 0.5 (unmodified) + printYourFreddies(f1, f2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + + assert(& lf`first == & f1); + assert(& lf`last == & f2); +} + +void test__insertbefore_before_first__mary() { + + mary m1 = {3.14}; + mary m2 = {0.5}; + + dlist(mary, mary) lm; + + assert(& lm`first == 0p); + assert(& lm`last == 0p); + + insert_last(lm, m2); + + assert(& lm`first == & m2); + assert(& lm`last == & m2); + + verify(validate(lm)); + + insert_before(m2, m1); + + verify(validate(lm)); + + printMariatheotokos(m1, m2, 0); // 3.14, 0.5; 3.14; 0.5; 0.5, 3.14 (modified) + + assert(& lm`first == & m1); + assert(& lm`last == & m2); +} + +//////////////////////////////////////////////////////////// +// +// Section 4d.i +// +// Test cases of remove, from middle of headless list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +// These tests, in the fred cases, set up the my/your lists initially identical, +// act on one list, and expect the other unaffected. + +void test__remove_mid__fred_mine() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + insert_after(f1`in_mine, f2); + insert_after(f2`in_mine, f3); + + insert_after(f1`in_yours, f2); + insert_after(f2`in_yours, f3); + + printMyFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(f2`in_mine); + + printMyFreddies(f1, f3, 0); // 1.7, 3.7; 1.7; 3.7; 3.7, 1.7 (modified) + printYourFreddies(f1, f3, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + + // observe f2 is now solo in mine; in yours, it was just traversed + printMyFreddies(f2, *0p, 0); // 2.7; 2.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f2.$links_mine.next.is_terminator == false); + assert(f2.$links_mine.prev.is_terminator == false); +} + +void test__remove_mid__fred_yours() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + insert_after(f1`in_mine, f2); + insert_after(f2`in_mine, f3); + + insert_after(f1`in_yours, f2); + insert_after(f2`in_yours, f3); + + printMyFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(f2`in_yours); + + printMyFreddies(f1, f3, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + printYourFreddies(f1, f3, 0); // 1.7, 3.7; 1.7; 3.7; 3.7, 1.7 (modified) + + // observe f2 is now solo in yours; in mine, it was just traversed + printYourFreddies(f2, *0p, 0); // 2.7; 2.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f2.$links_yours.next.is_terminator == false); + assert(f2.$links_yours.prev.is_terminator == false); +} + +void test__remove_mid__mary() { + + mary m1 = {1.7}; + mary m2 = {2.7}; + mary m3 = {3.7}; + + insert_after(m1, m2); + insert_after(m2, m3); + + printMariatheotokos(m1, m3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(m2); + + printMariatheotokos(m1, m3, 0); // 1.7, 3.7; 1.7; 3.7; 3.7, 1.7 (modified) + + // observe m2 is now solo + printMariatheotokos(m2, *0p, 0); // 2.7; 2.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(m2.$links.next.is_terminator == false); + assert(m2.$links.prev.is_terminator == false); +} + +//////////////////////////////////////////////////////////// +// +// Section 4d.ii +// +// Test cases of remove, from first position of headless list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +// TODO: validate headless semantic: remove of a neighbourless element is valid and no-op + +void test__remove_at_first__fred_mine() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + insert_after(f1`in_mine, f2); + insert_after(f2`in_mine, f3); + + insert_after(f1`in_yours, f2); + insert_after(f2`in_yours, f3); + + printMyFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(f1`in_mine); + + printMyFreddies(f2, f3, 0); // 2.7, 3.7; 2.7; 3.7; 3.7, 2.7 (modified) + printYourFreddies(f1, f3, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + + // observe f1 is now solo in mine; in yours, it was just traversed + printMyFreddies(f1, *0p, 0); // 1.7; 1.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f1.$links_mine.next.is_terminator == false); + assert(f1.$links_mine.prev.is_terminator == false); +} + +void test__remove_at_first__fred_yours() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + insert_after(f1`in_mine, f2); + insert_after(f2`in_mine, f3); + + insert_after(f1`in_yours, f2); + insert_after(f2`in_yours, f3); + + printMyFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(f1`in_yours); + + printMyFreddies(f1, f3, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + printYourFreddies(f2, f3, 0); // 2.7, 3.7; 2.7; 3.7; 3.7, 2.7 (modified) + + // observe f1 is now solo in yours; in mine, it was just traversed + printYourFreddies(f1, *0p, 0); // 1.7; 1.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f1.$links_yours.next.is_terminator == false); + assert(f1.$links_yours.prev.is_terminator == false); +} + +void test__remove_at_first__mary() { + + mary m1 = {1.7}; + mary m2 = {2.7}; + mary m3 = {3.7}; + + insert_after(m1, m2); + insert_after(m2, m3); + + printMariatheotokos(m1, m3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(m1); + + printMariatheotokos(m2, m3, 0); // 2.7, 3.7; 2.7; 3.7; 3.7, 2.7 (modified) + + // observe m2 is now solo + printMariatheotokos(m1, *0p, 0); // 1.7; 1.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(m1.$links.next.is_terminator == false); + assert(m1.$links.prev.is_terminator == false); +} + +//////////////////////////////////////////////////////////// +// +// Section 4d.iii +// +// Test cases of remove, from last position of headless list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +void test__remove_at_last__fred_mine() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + insert_after(f1`in_mine, f2); + insert_after(f2`in_mine, f3); + + insert_after(f1`in_yours, f2); + insert_after(f2`in_yours, f3); + + printMyFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(f3`in_mine); + + printMyFreddies(f1, f2, 0); // 1.7, 2.7; 1.7; 2.7; 2.7, 1.7 (modified) + printYourFreddies(f1, f3, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + + // observe f3 is now solo in mine; in yours, it was just traversed + printMyFreddies(f3, *0p, 0); // 3.7; 3.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f3.$links_mine.next.is_terminator == false); + assert(f3.$links_mine.prev.is_terminator == false); +} + +void test__remove_at_last__fred_yours() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + insert_after(f1`in_mine, f2); + insert_after(f2`in_mine, f3); + + insert_after(f1`in_yours, f2); + insert_after(f2`in_yours, f3); + + printMyFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(f1, f3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(f3`in_yours); + + printMyFreddies(f1, f3, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + printYourFreddies(f1, f2, 0); // 1.7, 2.7; 1.7; 2.7; 2.7, 1.7 (modified) + + // observe f3 is now solo in yours; in mine, it was just traversed + printYourFreddies(f3, *0p, 0); // 3.7; 3.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f3.$links_yours.next.is_terminator == false); + assert(f3.$links_yours.prev.is_terminator == false); +} + +void test__remove_at_last__mary() { + + mary m1 = {1.7}; + mary m2 = {2.7}; + mary m3 = {3.7}; + + insert_after(m1, m2); + insert_after(m2, m3); + + printMariatheotokos(m1, m3, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + remove(m3); + + printMariatheotokos(m1, m2, 0); // 1.7, 2.7; 1.7; 2.7; 2.7, 1.7 (modified) + + // observe m3 is now solo + printMariatheotokos(m3, *0p, 0); // 3.7; 3.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(m1.$links.next.is_terminator == false); + assert(m1.$links.prev.is_terminator == false); +} + +//////////////////////////////////////////////////////////// +// +// Section 4e.i +// +// Test cases of remove, from first position of headed list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +void test__remove_at_head__fred_mine() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + dlist(fred_in_mine, fred) flm; + insert_last(flm, f1); + insert_last(flm, f2); + insert_last(flm, f3); + + dlist(fred_in_yours, fred) fly; + insert_last(fly, f1); + insert_last(fly, f2); + insert_last(fly, f3); + + printMyFreddies(flm`first, flm`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(fly`first, fly`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + verify(validate(fly)); + verify(validate(flm)); + + remove(f1`in_mine); + + verify(validate(fly)); + verify(validate(flm)); + + printMyFreddies(flm`first, flm`last, 0); // 2.7, 3.7; 2.7; 3.7; 3.7, 2.7 (modified) + printYourFreddies(fly`first, fly`last, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + + // observe f1 is now solo in mine; in yours, it was just traversed + printMyFreddies(f1, *0p, 0); // 1.7; 1.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f1.$links_mine.next.is_terminator == false); + assert(f1.$links_mine.prev.is_terminator == false); +} + +void test__remove_at_head__fred_yours() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + dlist(fred_in_mine, fred) flm; + insert_last(flm, f1); + insert_last(flm, f2); + insert_last(flm, f3); + + dlist(fred_in_yours, fred) fly; + insert_last(fly, f1); + insert_last(fly, f2); + insert_last(fly, f3); + + printMyFreddies(flm`first, flm`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(fly`first, fly`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + verify(validate(fly)); + verify(validate(flm)); + + remove(f1`in_yours); + + verify(validate(fly)); + verify(validate(flm)); + + printMyFreddies(flm`first, flm`last, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + printYourFreddies(fly`first, fly`last, 0); // 2.7, 3.7; 2.7; 3.7; 3.7, 2.7 (modified) + + // observe f1 is now solo in yours; in mine, it was just traversed + printYourFreddies(f1, *0p, 0); // 1.7; 1.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f1.$links_yours.next.is_terminator == false); + assert(f1.$links_yours.prev.is_terminator == false); +} + +void test__remove_at_head__mary() { + + mary m1 = {1.7}; + mary m2 = {2.7}; + mary m3 = {3.7}; + + dlist(mary, mary) ml; + insert_last(ml, m1); + insert_last(ml, m2); + insert_last(ml, m3); + + printMariatheotokos(ml`first, ml`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + verify(validate(ml)); + + remove(m1); + + verify(validate(ml)); + + printMariatheotokos(ml`first, ml`last, 0); // 2.7, 3.7; 2.7; 3.7; 3.7, 2.7 (modified) + + // observe m1 is now solo + printMariatheotokos(m1, *0p, 0); // 1.7; 1.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(m1.$links.next.is_terminator == false); + assert(m1.$links.prev.is_terminator == false); +} + +//////////////////////////////////////////////////////////// +// +// Section 4e.ii +// +// Test cases of remove, from last position of headed list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +void test__remove_at_tail__fred_mine() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + dlist(fred_in_mine, fred) flm; + insert_last(flm, f1); + insert_last(flm, f2); + insert_last(flm, f3); + + dlist(fred_in_yours, fred) fly; + insert_last(fly, f1); + insert_last(fly, f2); + insert_last(fly, f3); + + printMyFreddies(flm`first, flm`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(fly`first, fly`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + verify(validate(fly)); + verify(validate(flm)); + + remove(f3`in_mine); + + verify(validate(fly)); + verify(validate(flm)); + + printMyFreddies(flm`first, flm`last, 0); // 1.7, 2.7; 1.7; 2.7; 2.7, 1.7 (modified) + printYourFreddies(fly`first, fly`last, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + + // observe f3 is now solo in mine; in yours, it was just traversed + printMyFreddies(f3, *0p, 0); // 3.7; 3.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f3.$links_mine.next.is_terminator == false); + assert(f3.$links_mine.prev.is_terminator == false); +} + +void test__remove_at_tail__fred_yours() { + + fred f1 = {1.7}; + fred f2 = {2.7}; + fred f3 = {3.7}; + + dlist(fred_in_mine, fred) flm; + insert_last(flm, f1); + insert_last(flm, f2); + insert_last(flm, f3); + + dlist(fred_in_yours, fred) fly; + insert_last(fly, f1); + insert_last(fly, f2); + insert_last(fly, f3); + + printMyFreddies(flm`first, flm`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + printYourFreddies(fly`first, fly`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + verify(validate(fly)); + verify(validate(flm)); + + remove(f3`in_yours); + + verify(validate(fly)); + verify(validate(flm)); + + printMyFreddies(flm`first, flm`last, 0); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 (unmodified) + printYourFreddies(fly`first, fly`last, 0); // 1.7, 2.7; 1.7; 2.7; 2.7, 1.7 (modified) + + // observe f3 is now solo in yours; in mine, it was just traversed + printYourFreddies(f3, *0p, 0); // 3.7; 3.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f3.$links_yours.next.is_terminator == false); + assert(f3.$links_yours.prev.is_terminator == false); +} + +void test__remove_at_tail__mary() { + + mary m1 = {1.7}; + mary m2 = {2.7}; + mary m3 = {3.7}; + + dlist(mary, mary) ml; + insert_last(ml, m1); + insert_last(ml, m2); + insert_last(ml, m3); + + printMariatheotokos(ml`first, ml`last, 1); // 1.7, 2.7, 3.7; 1.7; 3.7; 3.7, 2.7, 1.7 + + verify(validate(ml)); + + remove(m3); + + verify(validate(ml)); + + printMariatheotokos(ml`first, ml`last, 0); // 1.7, 2.7; 1.7; 2.7; 2.7, 1.7 (modified) + + // observe m3 is now solo + printMariatheotokos(m3, *0p, 0); //3.7; 3.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(m3.$links.next.is_terminator == false); + assert(m3.$links.prev.is_terminator == false); +} + +//////////////////////////////////////////////////////////// +// +// Section 4e.iii +// +// Test cases of remove, of sole element of headed list +// +// Example of call-side user code +// +//////////////////////////////////////////////////////////// + +void test__remove_of_sole__fred_mine() { + + fred f = {0.7}; + + dlist(fred_in_mine, fred) flm; + insert_last(flm, f); + + dlist(fred_in_yours, fred) fly; + insert_last(fly, f); + + printMyFreddies(flm`first, flm`last, 1); // 0.7; 0.7; 0.7; 0.7 + printYourFreddies(fly`first, fly`last, 1); // 0.7; 0.7; 0.7; 0.7 + + verify(validate(fly)); + verify(validate(flm)); + + remove(f`in_mine); + + verify(validate(fly)); + verify(validate(flm)); + + assert(& flm`first == 0p); + assert(& flm`last == 0p); + + printYourFreddies(fly`first, fly`last, 0); // 0.7; 0.7; 0.7; 0.7 (unmodified) + + // observe f is solo in mine (now unlisted); in yours, it was just traversed + printMyFreddies(f, *0p, 0); // 0.7; 0.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f.$links_mine.next.is_terminator == false); + assert(f.$links_mine.prev.is_terminator == false); + + insert_last(flm, f); + verify(validate(fly)); + verify(validate(flm)); + printMyFreddies(flm`first, flm`last, 0); // 0.7; 0.7; 0.7; 0.7 +} + +void test__remove_of_sole__fred_yours() { + + fred f = {0.7}; + + dlist(fred_in_mine, fred) flm; + insert_last(flm, f); + + dlist(fred_in_yours, fred) fly; + insert_last(fly, f); + + printMyFreddies(flm`first, flm`last, 1); // 0.7; 0.7; 0.7; 0.7 + printYourFreddies(fly`first, fly`last, 1); // 0.7; 0.7; 0.7; 0.7 + + verify(validate(fly)); + verify(validate(flm)); + + remove(f`in_yours); + + verify(validate(fly)); + verify(validate(flm)); + + assert(& fly`first == 0p); + assert(& fly`last == 0p); + + printYourFreddies(flm`first, flm`last, 0); // 0.7; 0.7; 0.7; 0.7 (unmodified) + + // observe f is solo in yours (now unlisted); in mine, it was just traversed + printYourFreddies(f, *0p, 0); // 0.7; 0.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(f.$links_yours.next.is_terminator == false); + assert(f.$links_yours.prev.is_terminator == false); + + insert_last(fly, f); + verify(validate(fly)); + verify(validate(flm)); + printYourFreddies(fly`first, fly`last, 0); // 0.7; 0.7; 0.7; 0.7 +} + +void test__remove_of_sole__mary() { + + mary m = {0.7}; + + dlist(mary, mary) ml; + insert_last(ml, m); + + printMariatheotokos(ml`first, ml`last, 1); // 0.7; 0.7; 0.7; 0.7 + + verify(validate(ml)); + + remove(m); + + verify(validate(ml)); + + assert(& ml`first == 0p); + assert(& ml`last == 0p); + + // observe f is solo in mine (now unlisted); in yours, it was just traversed + printMariatheotokos(m, *0p, 0); // 0.7; 0.7; ; + + // TODO: decide on appropriate ovservable outcome (is_listed?) and its itended semantics + assert(m.$links.next.is_terminator == false); + assert(m.$links.prev.is_terminator == false); + + insert_last(ml, m); + verify(validate(ml)); + printMariatheotokos(ml`first, ml`last, 0); // 0.7; 0.7; 0.7; 0.7 +} + +//////////////////////////////////////////////////////////// +// +// Section 5 +// +// Simple driver with the inter-scario printing +// +//////////////////////////////////////////////////////////// + +int main() { + + sout | "~~~~~~~~~~~~~~~~~ Headless List Tests - insert_after ~~~~~~~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 1-i: Modifying Freds on MINE "; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertafter_singleton_on_singleton__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 2-i. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertafter_singleton_on_singleton__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 3-i. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertafter_singleton_on_singleton__mary(); + + sout | ""; + sout | "~~~~~~~~~~~~~~~~ Headless List Tests - insert_before ~~~~~~~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 1-ii: Modifying Freds on MINE "; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertbefore_singleton_on_singleton__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 2-ii. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertbefore_singleton_on_singleton__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 3-ii. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertbefore_singleton_on_singleton__mary(); + + sout | ""; + sout | "~~~~~~~~~~~~~~~~~ Headed List Tests - insert_first ~~~~~~~~~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 4-i: Modifying Freds on MINE "; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertfirst_two_on_empty__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 5-i: Modifying Freds on YOURS "; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertfirst_two_on_empty__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 6-i. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertfirst_two_on_empty__mary(); + + sout | ""; + sout | "~~~~~~~~~~~~~~~~~ Headed List Tests - insert_last ~~~~~~~~~~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 4-ii: Modifying Freds on MINE "; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertlast_two_on_empty__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 5-ii: Modifying Freds on YOURS "; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertlast_two_on_empty__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 6-ii. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertlast_two_on_empty__mary(); + + sout | ""; + sout | "~~~~~~~~~~~ Element ops on Headed List Tests: after, last ~~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 7-i. Modifying Freds on MINE"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertafter_after_last__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 8-i. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertafter_after_last__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 9-i. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertafter_after_last__mary(); + + sout | ""; + sout | "~~~~~~~~~~ Element ops on Headed List Tests: before, first ~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 7-ii. Modifying Freds on MINE"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertbefore_before_first__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 8-ii. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertbefore_before_first__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 9-ii. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__insertbefore_before_first__mary(); + + sout | ""; + sout | "~~~~~~~~~~ Element removal tests on Headless List: mid ~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 10-i. Modifying Freds on MINE"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_mid__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 11-i. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_mid__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 12-i. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_mid__mary(); + + sout | ""; + sout | "~~~~~~~~~~ Element removal tests on Headless List: at first ~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 10-ii. Modifying Freds on MINE"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_first__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 11-ii. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_first__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 12-ii. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_first__mary(); + + sout | ""; + sout | "~~~~~~~~~~ Element removal tests on Headless List: at last ~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 10-iii. Modifying Freds on MINE"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_last__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 11-iii. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_last__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 12-iii. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_last__mary(); + + sout | ""; + sout | "~~~~~~~~~~ Element removal tests on Headed List: at first ~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 13-i. Modifying Freds on MINE"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_head__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 14-i. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_head__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 15-i. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_head__mary(); + + sout | ""; + sout | "~~~~~~~~~~ Element removal tests on Headed List: at last ~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 13-ii. Modifying Freds on MINE"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_tail__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 14-ii. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_tail__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 15-ii. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_at_tail__mary(); + + sout | ""; + sout | "~~~~~~~~~~ Element removal tests on Headed List: of sole ~~~~~~~~~~"; + sout | ""; + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 13-iii. Modifying Freds on MINE"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_of_sole__fred_mine(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 14-iii. Modifying Freds on YOURS"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_of_sole__fred_yours(); + + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + sout | "Test 15-iii. Modifying Maries"; + sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"; + test__remove_of_sole__mary(); + + return 0; +} Index: tests/manipulatorsOutput1.cfa =================================================================== --- tests/manipulatorsOutput1.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/manipulatorsOutput1.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -7,6 +7,6 @@ // Created On : Sat Jun 8 18:04:11 2019 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Jun 10 12:37:28 2019 -// Update Count : 8 +// Last Modified On : Fri May 1 11:51:44 2020 +// Update Count : 9 // @@ -17,43 +17,60 @@ signed char sc = -12; printf( "%hhd %2hhd %5.2hhd %-5.2hhd %hho %#hho %hhx %#hhx %#8hhx %#8.10hhx %#8.3hhX %+-8.3hhd %08hhd\n", sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc, sc ); - sout | sc | wd(2,sc) | wd(5,2,sc) | left(wd(5,2,sc)) | nobase(oct(sc)) | oct(sc) | nobase(hex(sc)) | hex(sc) | wd(8,hex(sc)) | wd(8,10,hex(sc)) | upcase(wd(8,3,hex(sc))) | left(sign(upcase(wd(8,3,sc)))) | pad0(wd(8,sc)); + sout | sc | wd(2,sc) | wd(5,2,sc) | left(wd(5,2,sc)) | nobase(oct(sc)) | oct(sc) | nonl; + sout | nobase(hex(sc)) | hex(sc) | wd(8,hex(sc)) | wd(8,10,hex(sc)) | upcase(wd(8,3,hex(sc))) | nonl; + sout | left(sign(upcase(wd(8,3,sc)))) | pad0(wd(8,sc)); sout | "unsigned char"; unsigned char usc = 12; printf( "%hhu %2hhu %5.2hhu %-5.2hhu %hho %#hho %hhx %#hhx %#8hhx %#8.10hhx %#8.3hhX %-8.3hhu %08hhu\n", usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc, usc ); - sout | usc | wd(2,usc) | wd(5,2,usc) | left(wd(5,2,usc)) | nobase(oct(usc)) | oct(usc) | nobase(hex(usc)) | hex(usc) | wd(8,hex(usc)) | wd(8,10,hex(usc)) | upcase(wd(8,3,hex(usc))) | left(upcase(wd(8,3,usc))) | pad0(wd(8,usc)); + sout | usc | wd(2,usc) | wd(5,2,usc) | left(wd(5,2,usc)) | nobase(oct(usc)) | oct(usc) | nonl; + sout | nobase(hex(usc)) | hex(usc) | wd(8,hex(usc)) | wd(8,10,hex(usc)) | upcase(wd(8,3,hex(usc))) | nonl; + sout | left(upcase(wd(8,3,usc))) | pad0(wd(8,usc)); sout | "signed short int"; signed short int si = -12; printf( "%hd %2hd %5.2hd %-5.2hd %ho %#ho %hx %#hx %#8hx %#8.10hx %#8.3hX %+-8.3hd %08hd\n", si, si, si, si, si, si, si, si, si, si, si, si, si ); - sout | si | wd(2,si) | wd(5,2,si) | left(wd(5,2,si)) | nobase(oct(si)) | oct(si) | nobase(hex(si)) | hex(si) | wd(8,hex(si)) | wd(8,10,hex(si)) | upcase(wd(8,3,hex(si))) | left(sign(upcase(wd(8,3,si)))) | pad0(wd(8,si)); + sout | si | wd(2,si) | wd(5,2,si) | left(wd(5,2,si)) | nobase(oct(si)) | oct(si) | nonl; + sout | nobase(hex(si)) | hex(si) | wd(8,hex(si)) | wd(8,10,hex(si)) | upcase(wd(8,3,hex(si))) | nonl; + sout | left(sign(upcase(wd(8,3,si)))) | pad0(wd(8,si)); sout | "unsigned short int"; unsigned short int usi = 12; printf( "%hu %2hu %5.2hu %-5.2hu %ho %#ho %hx %#hx %#8hx %#8.10hx %#8.3hX %-8.3hu %08hu\n", usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi, usi ); - sout | usi | wd(2,usi) | wd(5,2,usi) | left(wd(5,2,usi)) | nobase(oct(usi)) | oct(usi) | nobase(hex(usi)) | hex(usi) | wd(8,hex(usi)) | wd(8,10,hex(usi)) | upcase(wd(8,3,hex(usi))) | left(upcase(wd(8,3,usi))) | pad0(wd(8,usi)); + sout | usi | wd(2,usi) | wd(5,2,usi) | left(wd(5,2,usi)) | nobase(oct(usi)) | oct(usi) | nonl; + sout | nobase(hex(usi)) | hex(usi) | wd(8,hex(usi)) | wd(8,10,hex(usi)) | upcase(wd(8,3,hex(usi))) | nonl; + sout | left(upcase(wd(8,3,usi))) | pad0(wd(8,usi)); sout | "signed int"; signed int i = -12; printf( "%d %2d %5.2d %-5.2d %o %#o %x %#x %#8x %#8.10x %#8.3X %+-8.3d %08d\n", i, i, i, i, i, i, i, i, i, i, i, i, i ); - sout | i | wd(2,i) | wd(5,2,i) | left(wd(5,2,i)) | nobase(oct(i)) | oct(i) | nobase(hex(i)) | hex(i) | wd(8,hex(i)) | wd(8,10,hex(i)) | upcase(wd(8,3,hex(i))) | left(sign(upcase(wd(8,3,i)))) | pad0(wd(8,i)); + sout | i | wd(2,i) | wd(5,2,i) | left(wd(5,2,i)) | nobase(oct(i)) | oct(i) | nonl; + sout | nobase(hex(i)) | hex(i) | wd(8,hex(i)) | wd(8,10,hex(i)) | upcase(wd(8,3,hex(i))) | nonl; + sout | left(sign(upcase(wd(8,3,i)))) | pad0(wd(8,i)); sout | "unsigned int"; unsigned int ui = 12; printf( "%u %2u %5.2u %-5.2u %o %#o %x %#x %#8x %#8.10x %#8.3X %-8.3u %08u\n", ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui, ui ); - sout | ui | wd(2,ui) | wd(5,2,ui) | left(wd(5,2,ui)) | nobase(oct(ui)) | oct(ui) | nobase(hex(ui)) | hex(ui) | wd(8,hex(ui)) | wd(8,10,hex(ui)) | upcase(wd(8,3,hex(ui))) | left(upcase(wd(8,3,ui))) | pad0(wd(8,ui)); + sout | ui | wd(2,ui) | wd(5,2,ui) | left(wd(5,2,ui)) | nobase(oct(ui)) | oct(ui) | nonl; + sout | nobase(hex(ui)) | hex(ui) | wd(8,hex(ui)) | wd(8,10,hex(ui)) | upcase(wd(8,3,hex(ui))) | nonl; + sout | left(upcase(wd(8,3,ui))) | pad0(wd(8,ui)); sout | "signed long long int"; signed long long int lli = -12; printf( "%lld %2lld %5.2lld %-5.2lld %llo %#llo %llx %#llx %#8llx %#8.10llx %#8.3llX %+-8.3lld %08lld\n", lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli, lli ); - sout | lli | wd(2,lli) | wd(5,2,lli) | left(wd(5,2,lli)) | nobase(oct(lli)) | oct(lli) | nobase(hex(lli)) | hex(lli) | wd(8,hex(lli)) | wd(8,10,hex(lli)) | upcase(wd(8,3,hex(lli))) | left(sign(upcase(wd(8,3,lli)))) | pad0(wd(8,lli)); + sout | lli | wd(2,lli) | wd(5,2,lli) | left(wd(5,2,lli)) | nobase(oct(lli)) | oct(lli) | nonl; + sout | nobase(hex(lli)) | hex(lli) | wd(8,hex(lli)) | wd(8,10,hex(lli)) | upcase(wd(8,3,hex(lli))) | nonl; + sout | left(sign(upcase(wd(8,3,lli)))) | pad0(wd(8,lli)); sout | "unsigned long long int"; unsigned long long int ulli = 12; printf( "%llu %2llu %5.2llu %-5.2llu %llo %#llo %llx %#llx %#8llx %#8.10llx %#8.3llX %-8.3llu %08llu\n", ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli, ulli ); - sout | ulli | wd(2,ulli) | wd(5,2,ulli) | left(wd(5,2,ulli)) | nobase(oct(ulli)) | oct(ulli) | nobase(hex(ulli)) | hex(ulli) | wd(8,hex(ulli)) | wd(8,10,hex(ulli)) | upcase(wd(8,3,hex(ulli))) | left(upcase(wd(8,3,ulli))) | pad0(wd(8,ulli)); + sout | ulli | wd(2,ulli) | wd(5,2,ulli) | left(wd(5,2,ulli)) | nobase(oct(ulli)) | oct(ulli) | nonl; + sout | nobase(hex(ulli)) | hex(ulli) | wd(8,hex(ulli)) | wd(8,10,hex(ulli)) | upcase(wd(8,3,hex(ulli))) | nonl; + sout | left(upcase(wd(8,3,ulli))) | pad0(wd(8,ulli)); sout | nl | "binary integral"; - sout | bin(0) | bin(13) | upcase(bin(13)) | nobase(bin(13)) | left(wd(8,bin(13))) | wd(8,bin(13)) | pad0(left(wd(8,bin(13)))) | pad0(wd(8,bin(13))) | pad0(wd(8,10,bin(13))) | pad0(wd(8,6,bin(13))); + sout | bin(0) | bin(13) | upcase(bin(13)) | nobase(bin(13)) | left(wd(8,bin(13))) | wd(8,bin(13)) | nonl; + sout | pad0(left(wd(8,bin(13)))) | pad0(wd(8,bin(13))) | pad0(wd(8,10,bin(13))) | pad0(wd(8,6,bin(13))); @@ -62,5 +79,7 @@ printf( "%g %8g %#8g %g %8g %8.0g %#8.0g %8.2g %#8.2g %-8.2g %-8.2g %-#8.2g %-+8.2g %-+#8.2g %08.2g %8.2E %8.2a %#8.2A %#8.2e\n", 0.0,3.0F,3.0F, f, f, f, f, f, f, 3.0F, f, f, f, f, f, f, f, f, f ); - sout | 0.0 | wd(8, 3.0F) | nodp(wd(8, 3.0F)) | f | wd(8, f) | ws(8,0, f) | nodp(ws(8,0, f)) | ws(8,2, f) | nodp(ws(8,2, f)) | left(ws(8,2, 3.0F)) | left(ws(8,2, f)) | left(nodp(ws(8,2, f))) | left(sign(ws(8,2, f))) | left(sign(nodp(ws(8,2, f)))) | pad0(ws(8,2, f)) | upcase(wd(8,2, sci(f))) | wd(8,2, hex(f)) | upcase(wd(8,2, hex(f))) | nodp(wd(8,2, sci(f))); + sout | 0.0 | wd(8, 3.0F) | nodp(wd(8, 3.0F)) | f | wd(8, f) | ws(8,0, f) | nodp(ws(8,0, f)) | ws(8,2, f) | nodp(ws(8,2, f)) | nonl; + sout | left(ws(8,2, 3.0F)) | left(ws(8,2, f)) | left(nodp(ws(8,2, f))) | left(sign(ws(8,2, f))) | left(sign(nodp(ws(8,2, f)))) | nonl; + sout | pad0(ws(8,2, f)) | upcase(wd(8,2, sci(f))) | wd(8,2, hex(f)) | upcase(wd(8,2, hex(f))) | nodp(wd(8,2, sci(f))); sout | "double"; @@ -68,5 +87,6 @@ printf( "%g %#8f %g %8f %#8.0f %8.0f %8.2f %-8.2f %-+#8.2f %08.2F %8.2E %8.2a %8.2A %8.2e\n", 0.0, 3.0, d, d, d, d, d, d, d, d, d, d, d, d ); - sout | 0.0 | wd(8, 3.0) | d | wd(8, d) | nodp(wd(8,0, d)) | wd(8,0, d) | wd(8,2, d) | left(wd(8,2, d)) | left(sign(wd(8,2, d))) | pad0(upcase(wd(8,2, d))) | upcase(wd(8,2, sci(d))) | wd(8,2, hex(d)) | upcase(wd(8,2, hex(d))) | wd(8,2, sci(d)); + sout | 0.0 | wd(8, 3.0) | d | wd(8, d) | nodp(wd(8,0, d)) | wd(8,0, d) | wd(8,2, d) | nonl; + sout | left(wd(8,2, d)) | left(sign(wd(8,2, d))) | pad0(upcase(wd(8,2, d))) | upcase(wd(8,2, sci(d))) | wd(8,2, hex(d)) | upcase(wd(8,2, hex(d))) | wd(8,2, sci(d)); sout | "long double"; @@ -74,5 +94,6 @@ printf( "%Lg %#8Lf %Lg %8Lf %#8.0Lf %8.0Lf %8.2Lf %-8.2Lf %-+#8.2Lf %08.2LF %8.2LE %8.2La %8.2LA %8.2Le\n", 0.0L, 3.0L, ld, ld, ld, ld, ld, ld, ld, ld, ld, ld, ld, ld ); - sout | 0.0L | wd(8, 3.0L) | ld | wd(8, ld) | nodp(wd(8,0, ld)) | wd(8,0, ld) | wd(8,2, ld) | left(wd(8,2, ld)) | left(sign(wd(8,2, ld))) | pad0(upcase(wd(8,2, ld))) | upcase(wd(8,2, sci(ld))) | wd(8,2, hex(ld)) | upcase(wd(8,2, hex(ld))) | wd(8,2, sci(ld)); + sout | 0.0L | wd(8, 3.0L) | ld | wd(8, ld) | nodp(wd(8,0, ld)) | wd(8,0, ld) | wd(8,2, ld) | nonl; + sout | left(wd(8,2, ld)) | left(sign(wd(8,2, ld))) | pad0(upcase(wd(8,2, ld))) | upcase(wd(8,2, sci(ld))) | wd(8,2, hex(ld)) | upcase(wd(8,2, hex(ld))) | wd(8,2, sci(ld)); @@ -80,5 +101,6 @@ char c = 'a'; printf( "%c %2c %5c %-5c %hho %#hho %hhx %#hhx %#8hhx %#8hhX %-8c %8c\n", c, c, c, c, c, c, c, c, c, c, c, c ); - sout | c | ' ' | wd(2,c) | wd(5,c) | left(wd(5,c)) | nobase(oct(c)) | oct(c) | nobase(hex(c)) | hex(c) | wd(8,hex(c)) | upcase(wd(8,hex(c))) | left(wd(8,c)) | wd(8,c); + sout | c | ' ' | wd(2,c) | wd(5,c) | left(wd(5,c)) | nobase(oct(c)) | oct(c) | nonl; + sout | nobase(hex(c)) | hex(c) | wd(8,hex(c)) | upcase(wd(8,hex(c))) | left(wd(8,c)) | wd(8,c); sout | nl | "string"; Index: tests/manipulatorsOutput3.cfa =================================================================== --- tests/manipulatorsOutput3.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) +++ tests/manipulatorsOutput3.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -0,0 +1,143 @@ +#include +int main() { + int128 x = 0xffff, y = 0x2; + x <<= 64; + x += 0xffff; + y <<= 64; + y += 0123; + y |= 0x8000000000000000; + x = -x; + sout | x; + sout | sign(x); + x = -x; + sout | sign(x); + sout | nl; +#if 1 + sout | bin(x); + sout | upcase(bin(x)); + sout | nobase(bin(x)); + sout | wd( 95, upcase(bin(x)) ); + sout | wd( 95,90, upcase(bin(x)) ); + sout | wd( 25,30, upcase(hex(x)) ); + sout | nl; + + printf( "%#.10o\n", 0123 ); + sout | wd( 1,10, oct(0123) ); + sout | oct(x); + sout | nobase(oct(x)); + sout | wd( 45, oct(0123) ); + sout | wd( 45,40, oct(0123) ); + sout | wd( 40,45, oct(0123) ); + sout | wd( 45, oct(x) ); + sout | wd( 45,40, oct(x) ); + sout | wd( 40,45, oct(x) ); + + sout | left(wd( 45, oct(0123) )) | 'X'; + sout | left(wd( 45, oct(x) )) | 'X'; + sout | left(wd( 45, oct(y) )) | 'X'; + sout | left(wd( 45,40, oct(0123) )) | 'X'; + sout | left(wd( 45,40, oct(x) )) | 'X'; + sout | left(wd( 45,40, oct(y) )) | 'X'; + sout | left(wd( 40,45, oct(0123) )) | 'X'; + sout | left(wd( 40,45, oct(x) )) | 'X'; + sout | left(wd( 40,45, oct(y) )) | 'X'; + printf( "%#-1.10oX\n", 0123 ); + sout | left(wd( 1,10, oct(0123) )) | 'X'; + printf( "%#-40.10oX\n", 0123 ); + sout | left(wd( 40,10, oct(0123) )) | 'X'; + sout | left(wd( 40,10, oct(x) )) | 'X'; + sout | left(wd( 40,10, oct(y) )) | 'X'; + sout | left(wd( 10,40, oct(0123) )) | 'X'; + sout | left(wd( 10,40, oct(x) )) | 'X'; + sout | left(wd( 10,40, oct(y) )) | 'X'; + + y = 01234567; + sout | left(wd( 45, 49, oct(y) )) | 'X'; + y = -y; + sout | wd(0, oct(y)) | 'Y'; + sout | left(wd(0, oct(y))) | 'Y'; + sout | nl; + + sout | hex(x); + sout | upcase(hex(x)); + sout | nobase(hex(x)); + sout | wd( 45, upcase(hex(x)) ); + sout | wd( 45,40, upcase(hex(x)) ); + sout | wd( 45,49, upcase(hex(x)) ); + sout | left(wd( 45, upcase(hex(x)) )) | 'X'; + sout | left(wd( 45,40, upcase(hex(x)) )) | 'X'; + sout | left(wd( 45,49, upcase(hex(x)) )) | 'X'; + + sout | nl; + + int128 divisor = 0x4b3b4ca85a86c47a; + divisor <<= 16; + divisor += 0x98a224000000000; + + // base 2 + sout | "base 2"; + sout | bin(divisor); + sout | upcase(bin(divisor)); + sout | wd(38, upcase(bin(divisor))); + sout | wd(40, upcase(bin(divisor))); + sout | wd(40, 38, upcase(bin(divisor))); + sout | wd(40, 30, upcase(bin(divisor))); + sout | pad0(sign(wd(40, 38, upcase(bin(divisor))))); + sout | nl; + + // oct + sout | "base 8"; + sout | upcase(oct(divisor)); + sout | wd(38, upcase(oct(divisor))); + sout | wd(40, upcase(oct(divisor))); + sout | wd(40, 38, upcase(oct(divisor))); + sout | wd(40, 30, upcase(oct(divisor))); + sout | pad0(sign(wd(40, 38, upcase(oct(divisor))))); + sout | nl; + + // decimal + sout | "base 10"; + sout | divisor; + sout | wd(2, divisor); + sout | wd(3, divisor); + sout | wd(10, divisor); + sout | wd(24, divisor); + sout | wd(38, divisor); + sout | wd(39, divisor); + sout | wd(40, divisor); + + sout | wd(40, 30, divisor); + sout | wd(40, 38, divisor); + sout | wd(40, 40, divisor); + sout | pad0(wd(40, divisor)); + sout | pad0(sign(wd(40,divisor))); + sout | nl; + + // hex + sout | "base 16"; + sout | upcase(hex(divisor)); + sout | wd(38, upcase(hex(divisor))); + sout | wd(40, upcase(hex(divisor))); + sout | wd(40, 38, upcase(hex(divisor))); + sout | wd(40, 30, upcase(hex(divisor))); + sout | pad0(sign(wd(40, 38, upcase(hex(divisor))))); + sout | nl; + + + sout | bin(divisor); + sout | upcase(bin(divisor)); + sout | oct(divisor); + sout | hex(divisor); + sout | upcase(hex(divisor)); + sout | nobase(bin(divisor)) | nobase(oct(divisor)) | nobase(hex(divisor)); + sout | sign(divisor); + sout | -divisor; + sout | sign(-divisor); + sout | wd(2, divisor); + sout | wd(3,10,divisor); + sout | left(wd(40,divisor)) | 'X'; + sout | left(sign(wd(40, divisor))) | 'X'; + sout | left(sign(wd(0,40, divisor))) | 'X'; + printf( "%-+1.40dX\n", 123456789 ); +#endif // 0 +} Index: tests/pybin/settings.py =================================================================== --- tests/pybin/settings.py (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/pybin/settings.py (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -23,15 +23,15 @@ class Architecture: KnownArchitectures = { - 'x64' : 'x64', - 'x86-64' : 'x64', - 'x86_64' : 'x64', - 'x86' : 'x86', - 'aarch64' : 'arm', - 'i386' : 'x86', - 'i486' : 'x86', - 'i686' : 'x86', - 'Intel 80386' : 'x86', - 'arm' : 'arm', - 'ARM' : 'arm', + 'x64' : 'x64', + 'x86-64' : 'x64', + 'x86_64' : 'x64', + 'x86' : 'x86', + 'aarch64' : 'arm', + 'i386' : 'x86', + 'i486' : 'x86', + 'i686' : 'x86', + 'Intel 80386' : 'x86', + 'arm' : 'arm', + 'ARM' : 'arm', } @@ -81,6 +81,6 @@ return True if not arch else self.target == arch - @classmethod - def make_canonical(_, arch): + @staticmethod + def make_canonical(arch): return Architecture.KnownArchitectures[arch] @@ -105,6 +105,6 @@ self.total = Timeouts.check(tg) - @classmethod - def check(_, value): + @staticmethod + def check(value): if value < 1: print("Timeouts must be at least 1 second", file=sys.stderr) @@ -129,5 +129,5 @@ global timeout2gdb - all_arch = [Architecture(o) for o in list(dict.fromkeys(options.arch ))] + all_arch = [Architecture(o) for o in list(dict.fromkeys(options.arch ))] if options.arch else [Architecture(None)] all_debug = [Debug(o) for o in list(dict.fromkeys(options.debug ))] all_install = [Install(o) for o in list(dict.fromkeys(options.install))] Index: tests/pybin/test_run.py =================================================================== --- tests/pybin/test_run.py (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/pybin/test_run.py (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -40,14 +40,14 @@ return os.path.normpath( os.path.join(settings.BUILDDIR, self.path, self.name) ) - @classmethod - def valid_name(_, name): + @staticmethod + def valid_name(name): return not name.endswith( ('.c', '.cc', '.cpp', '.cfa') ) - @classmethod - def from_target(_, target): + @staticmethod + def new_target(target, arch): test = Test() test.name = os.path.basename(target) test.path = os.path.relpath (os.path.dirname(target), settings.SRCDIR) - test.arch = settings.arch.target if settings.arch.cross_compile else '' + test.arch = arch.target if arch else '' return test @@ -72,6 +72,6 @@ return text - @classmethod - def fmtDur( cls, duration ): + @staticmethod + def fmtDur( duration ): if duration : hours, rem = divmod(duration, 3600) Index: tests/test.py =================================================================== --- tests/test.py (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/test.py (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -67,7 +67,30 @@ for testname in options.tests : testname = canonical_path( testname ) + # first check if this is a valid name to regenerate if Test.valid_name(testname): + # this is a valid name, let's check if it already exists found = [test for test in all_tests if canonical_path( test.target() ) == testname] - tests.append( found[0] if len(found) == 1 else Test.from_target(testname) ) + if not found: + # it's a new name, create it according to the name and specified architecture + if options.arch: + # user specified one or multiple architectures, assume the tests will have architecture specific results + tests.extend( [Test.new_target(testname, arch) for arch in settings.all_arch] ) + else: + # user didn't specify an architecture, just create a cross platform test + tests.append( Test.new_target( testname, None ) ) + elif len(found) == 1 and not found[0].arch: + # we found a single test, the user better be wanting to create a cross platform test + if options.arch: + print('ERROR: "%s", test has no specified architecture but --arch was specified, ignoring it' % testname, file=sys.stderr) + else: + tests.append( found[0] ) + else: + # this test is already cross platform, just add a test for each platform the user asked + tests.extend( [Test.new_target(testname, arch) for arch in settings.all_arch] ) + + # print a warning if it users didn't ask for a specific architecture + if not options.arch: + print('WARNING: "%s", test has architecture specific expected files but --arch was not specified, regenerating only for current host' % testname, file=sys.stderr) + else : print('ERROR: "%s", tests are not allowed to end with a C/C++/CFA extension, ignoring it' % testname, file=sys.stderr) @@ -91,5 +114,5 @@ parser.add_argument('--debug', help='Run all tests in debug or release', type=comma_separated(yes_no), default='yes') 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('--arch', help='Test for specific architecture', type=comma_separated(str), default='') + parser.add_argument('--arch', help='Test for specific architecture', type=comma_separated(str), default=None) 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('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=60) @@ -183,6 +206,9 @@ else: - with open (out_file, "r") as myfile: - error = myfile.read() + if os.stat(out_file).st_size < 1048576: + with open (out_file, "r") as myfile: + error = myfile.read() + else: + error = "Output log can't be read, file is bigger than 1MB, see {} for actual error\n".format(out_file) ret, info = core_info(exe_file) @@ -220,5 +246,5 @@ return False, "" except Exception as ex: - print("Unexpected error in worker thread: %s" % ex, file=sys.stderr) + print("Unexpected error in worker thread running {}: {}".format(t.target(), ex), file=sys.stderr) sys.stderr.flush() return False, "" Index: tests/vector.cfa =================================================================== --- tests/vector.cfa (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tests/vector.cfa (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -14,6 +14,6 @@ // +#include #include -#include #undef assert @@ -28,4 +28,8 @@ int main() { vector( int ) iv; + + assert( ((uintptr_t)&iv.storage.storage ) == (((uintptr_t)&iv)) ); + assert( ((uintptr_t)&iv.storage.capacity) == (((uintptr_t)&iv) + sizeof(void *)) ); + assert( ((uintptr_t)&iv.size ) == (((uintptr_t)&iv) + sizeof(void *) + sizeof(size_t)) ); assert( empty( &iv ) ); Index: tools/build/push2dist.sh =================================================================== --- tools/build/push2dist.sh (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tools/build/push2dist.sh (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -19,5 +19,5 @@ # echo "Copying to machines : ${hosts} (hash=${hash})" -files="../../../driver/cfa ../../../driver/cfa-cpp ../../../driver/cc1 ../../../driver/as $(find . -name '*.c*' | tr '\n' ' ')" +files="../../../driver/cfa ../../../driver/cfa-cpp ../../../driver/cc1 ../../../driver/as defines.hfa $(find . -name '*.c*' | tr '\n' ' ')" # echo "Files ${files}" Index: tools/gdb/utils-gdb.py =================================================================== --- tools/gdb/utils-gdb.py (revision e3bc51c60b9c9b6ea0e677c0358ab2c534e41a95) +++ tools/gdb/utils-gdb.py (revision bcd74f39489d76f21240e6f14a5e7aae3956aa09) @@ -26,14 +26,14 @@ class ThreadInfo: - tid = 0 - cluster = None - value = None - - def __init__(self, cluster, value): - self.cluster = cluster - self.value = value - - def is_system(self): - return False + tid = 0 + cluster = None + value = None + + def __init__(self, cluster, value): + self.cluster = cluster + self.value = value + + def is_system(self): + return False # A named tuple representing information about a stack @@ -51,709 +51,546 @@ def is_cforall(): - return True + return True def get_cfa_types(): - # GDB types for various structures/types in CFA - return CfaTypes(cluster_ptr = gdb.lookup_type('struct cluster').pointer(), - processor_ptr = gdb.lookup_type('struct processor').pointer(), - thread_ptr = gdb.lookup_type('struct $thread').pointer(), - int_ptr = gdb.lookup_type('int').pointer(), - thread_state = gdb.lookup_type('enum coroutine_state')) + # GDB types for various structures/types in CFA + return CfaTypes(cluster_ptr = gdb.lookup_type('struct cluster').pointer(), + processor_ptr = gdb.lookup_type('struct processor').pointer(), + thread_ptr = gdb.lookup_type('struct $thread').pointer(), + int_ptr = gdb.lookup_type('int').pointer(), + thread_state = gdb.lookup_type('enum coroutine_state')) def get_addr(addr): - """ - NOTE: sketchy solution to retrieve address. There is a better solution... - @addr: str of an address that can be in a format 0xfffff - Return: str of just the address - """ - str_addr = str(addr) - ending_addr_index = str_addr.find('<') - if ending_addr_index == -1: - return str(addr) - return str_addr[:ending_addr_index].strip() + """ + NOTE: sketchy solution to retrieve address. There is a better solution... + @addr: str of an address that can be in a format 0xfffff + Return: str of just the address + """ + str_addr = str(addr) + ending_addr_index = str_addr.find('<') + if ending_addr_index == -1: + return str(addr) + return str_addr[:ending_addr_index].strip() def print_usage(obj): - print(obj.__doc__) + print(obj.__doc__) def parse(args): - """ - Split the argument list in string format, where each argument is separated - by whitespace delimiter, to a list of arguments like argv - @args: str of arguments - Return: - [] if args is an empty string - list if args is not empty - """ - # parse the string format of arguments and return a list of arguments - argv = args.split(' ') - if len(argv) == 1 and argv[0] == '': - return [] - return argv + """ + Split the argument list in string format, where each argument is separated + by whitespace delimiter, to a list of arguments like argv + @args: str of arguments + Return: + [] if args is an empty string + list if args is not empty + """ + # parse the string format of arguments and return a list of arguments + argv = args.split(' ') + if len(argv) == 1 and argv[0] == '': + return [] + return argv def get_cluster_root(): - """ - Return: gdb.Value of globalClusters.root (is an address) - """ - cluster_root = gdb.parse_and_eval('_X11mainClusterPS7cluster_1') - if cluster_root.address == 0x0: - print('No clusters, program terminated') - return cluster_root + """ + Return: gdb.Value of globalClusters.root (is an address) + """ + cluster_root = gdb.parse_and_eval('_X11mainClusterPS7cluster_1') + if cluster_root.address == 0x0: + print('No clusters, program terminated') + return cluster_root def find_curr_thread(): - # btstr = gdb.execute('bt', to_string = True).splitlines() - # if len(btstr) == 0: - # print('error') - # return None - # return btstr[0].split('this=',1)[1].split(',')[0].split(')')[0] - return None + # btstr = gdb.execute('bt', to_string = True).splitlines() + # if len(btstr) == 0: + # print('error') + # return None + # return btstr[0].split('this=',1)[1].split(',')[0].split(')')[0] + return None + +def all_clusters(): + if not is_cforall(): + return None + + cluster_root = get_cluster_root() + if cluster_root.address == 0x0: + return + + curr = cluster_root + ret = [curr] + + while True: + curr = curr['_X4nodeS26__cluster____dbg_node_cltr_1']['_X4nextPS7cluster_1'] + if curr == cluster_root: + break + + ret.append(curr) + + return ret + def lookup_cluster(name = None): - """ - Look up a cluster given its ID - @name: str - Return: gdb.Value - """ - if not is_cforall(): - return None - - root = get_cluster_root() - if root.address == 0x0: - return None - - if not name: - return root - - # lookup for the task associated with the id - cluster = None - curr = root - while True: - if curr['_X4namePKc_1'].string() == name: - cluster = curr.address - break - curr = curr['_X4nodeS26__cluster____dbg_node_cltr_1']['_X4nextPS7cluster_1'] - if curr == root or curr == 0x0: - break - - if not cluster: - print("Cannot find a cluster with the name: {}.".format(name)) - return None - - return cluster + """ + Look up a cluster given its ID + @name: str + Return: gdb.Value + """ + if not is_cforall(): + return None + + root = get_cluster_root() + if root.address == 0x0: + return None + + if not name: + return root + + # lookup for the task associated with the id + cluster = None + curr = root + while True: + if curr['_X4namePKc_1'].string() == name: + cluster = curr.address + break + curr = curr['_X4nodeS26__cluster____dbg_node_cltr_1']['_X4nextPS7cluster_1'] + if curr == root or curr == 0x0: + break + + if not cluster: + print("Cannot find a cluster with the name: {}.".format(name)) + return None + + return cluster def lookup_threads_by_cluster(cluster): - # Iterate through a circular linked list of threads and accumulate them in an array - threads = [] - - cfa_t = get_cfa_types() - root = cluster['_X7threadsS8__dllist_S7$thread__1']['_X4headPY15__TYPE_generic__1'].cast(cfa_t.thread_ptr) - - if root == 0x0 or root.address == 0x0: - print('There are no tasks for cluster: {}'.format(cluster)) - return threads - - curr = root - tid = 0 - sid = -1 - - while True: - t = ThreadInfo(cluster, curr) - if t.is_system(): - t.tid = sid - sid -= 1 - else: - t.tid = tid - tid += 1 - - threads.append(t) - - curr = curr['node']['next'] - if curr == root or curr == 0x0: - break - - return threads + # Iterate through a circular linked list of threads and accumulate them in an array + threads = [] + + cfa_t = get_cfa_types() + root = cluster['_X7threadsS8__dllist_S7$thread__1']['_X4headPY15__TYPE_generic__1'].cast(cfa_t.thread_ptr) + + if root == 0x0 or root.address == 0x0: + print('There are no tasks for cluster: {}'.format(cluster)) + return threads + + curr = root + tid = 0 + sid = -1 + + while True: + t = ThreadInfo(cluster, curr) + if t.is_system(): + t.tid = sid + sid -= 1 + else: + t.tid = tid + tid += 1 + + threads.append(t) + + curr = curr['node']['next'] + if curr == root or curr == 0x0: + break + + return threads def system_thread(thread): - return False + return False def adjust_stack(pc, fp, sp): - # pop sp, fp, pc from global stack - gdb.execute('set $pc = {}'.format(pc)) - gdb.execute('set $rbp = {}'.format(fp)) - gdb.execute('set $sp = {}'.format(sp)) + # pop sp, fp, pc from global stack + gdb.execute('set $pc = {}'.format(pc)) + gdb.execute('set $rbp = {}'.format(fp)) + gdb.execute('set $sp = {}'.format(sp)) ############################ COMMAND IMPLEMENTATION ######################### class Clusters(gdb.Command): - """Cforall: Display currently known clusters + """Cforall: Display currently known clusters Usage: - info clusters : print out all the clusters + info clusters : print out all the clusters """ - def __init__(self): - super(Clusters, self).__init__('info clusters', gdb.COMMAND_USER) - - def print_cluster(self, cluster_name, cluster_address): - print('{:>20} {:>20}'.format(cluster_name, cluster_address)) - - #entry point from gdb - def invoke(self, arg, from_tty): - if not is_cforall(): - return - - if arg: - print("info clusters does not take arguments") - print_usage(self) - return - - cluster_root = get_cluster_root() - if cluster_root.address == 0x0: - return - - curr = cluster_root - self.print_cluster('Name', 'Address') - - while True: - self.print_cluster(curr['_X4namePKc_1'].string(), str(curr)) - curr = curr['_X4nodeS26__cluster____dbg_node_cltr_1']['_X4nextPS7cluster_1'] - if curr == cluster_root: - break - - print("") + def __init__(self): + super(Clusters, self).__init__('info clusters', gdb.COMMAND_USER) + + def print_cluster(self, cluster_name, cluster_address): + print('{:>20} {:>20}'.format(cluster_name, cluster_address)) + + #entry point from gdb + def invoke(self, arg, from_tty): + if not is_cforall(): + return + + if arg: + print("info clusters does not take arguments") + print_usage(self) + return + + self.print_cluster('Name', 'Address') + + for c in all_clusters(): + self.print_cluster(c['_X4namePKc_1'].string(), str(c)) + + print("") ############ class Processors(gdb.Command): - """Cforall: Display currently known processors + """Cforall: Display currently known processors Usage: - info processors : print out all the processors in the Main Cluster - info processors : print out all processors in a given cluster + info processors : print out all the processors in the Main Cluster + info processors all : print out all processors in all clusters + info processors : print out all processors in a given cluster """ - def __init__(self): - super(Processors, self).__init__('info processors', gdb.COMMAND_USER) - - def print_processor(self, name, status, pending, address): - print('{:>20} {:>11} {:>13} {:>20}'.format(name, status, pending, address)) - - def iterate_procs(self, root, active): - if root == 0x0: - return - - cfa_t = get_cfa_types() - curr = root - - while True: - processor = curr - should_stop = processor['_X12do_terminateVb_1'] - stop_count = processor['_X10terminatedS9semaphore_1']['_X5counti_1'] - if not should_stop: - status = 'Active' if active else 'Idle' - else: - status_str = 'Last Thread' if stop_count >= 0 else 'Terminating' - status = '{}({},{})'.format(status_str, should_stop, stop_count) - - self.print_processor(processor['_X4namePKc_1'].string(), - status, str(processor['_X18pending_preemptionb_1']), str(processor) - ) - - curr = curr['_X4nodeS28__processor____dbg_node_proc_1']['_X4nextPS9processor_1'] - - if curr == root or curr == 0x0: - break - - #entry point from gdb - def invoke(self, arg, from_tty): - if not is_cforall(): - return - - cluster = lookup_cluster(arg if arg else None) - - if not cluster: - print("No Cluster matching arguments found") - return - - cfa_t = get_cfa_types() - print('Cluster: "{}"({})'.format(cluster['_X4namePKc_1'].string(), cluster.cast(cfa_t.cluster_ptr))) - - active_root = cluster.cast(cfa_t.cluster_ptr) \ - ['_X5procsS8__dllist_S9processor__1'] \ - ['_X4headPY15__TYPE_generic__1'] \ - .cast(cfa_t.processor_ptr) - - idle_root = cluster.cast(cfa_t.cluster_ptr) \ - ['_X5idlesS8__dllist_S9processor__1'] \ - ['_X4headPY15__TYPE_generic__1'] \ - .cast(cfa_t.processor_ptr) - - if idle_root != 0x0 or active_root != 0x0: - self.print_processor('Name', 'Status', 'Pending Yield', 'Address') - self.iterate_procs(active_root, True) - self.iterate_procs(idle_root, False) - else: - print("No processors on cluster") - - print() + def __init__(self): + super(Processors, self).__init__('info processors', gdb.COMMAND_USER) + + def print_processor(self, name, status, pending, address): + print('{:>20} {:>11} {:>13} {:>20}'.format(name, status, pending, address)) + + def iterate_procs(self, root, active): + if root == 0x0: + return + + cfa_t = get_cfa_types() + curr = root + + while True: + processor = curr + should_stop = processor['_X12do_terminateVb_1'] + stop_count = processor['_X10terminatedS9semaphore_1']['_X5counti_1'] + if not should_stop: + status = 'Active' if active else 'Idle' + else: + status_str = 'Last Thread' if stop_count >= 0 else 'Terminating' + status = '{}({},{})'.format(status_str, should_stop, stop_count) + + self.print_processor(processor['_X4namePKc_1'].string(), + status, str(processor['_X18pending_preemptionb_1']), str(processor) + ) + + curr = curr['_X4nodeS28__processor____dbg_node_proc_1']['_X4nextPS9processor_1'] + + if curr == root or curr == 0x0: + break + + #entry point from gdb + def invoke(self, arg, from_tty): + if not is_cforall(): + return + + if not arg: + clusters = [lookup_cluster(None)] + elif arg == "all": + clusters = all_clusters() + else: + clusters = [lookup_cluster(arg)] + + if not clusters: + print("No Cluster matching arguments found") + return + + cfa_t = get_cfa_types() + for cluster in clusters: + print('Cluster: "{}"({})'.format(cluster['_X4namePKc_1'].string(), cluster.cast(cfa_t.cluster_ptr))) + + active_root = cluster.cast(cfa_t.cluster_ptr) \ + ['_X5procsS8__dllist_S9processor__1'] \ + ['_X4headPY15__TYPE_generic__1'] \ + .cast(cfa_t.processor_ptr) + + idle_root = cluster.cast(cfa_t.cluster_ptr) \ + ['_X5idlesS8__dllist_S9processor__1'] \ + ['_X4headPY15__TYPE_generic__1'] \ + .cast(cfa_t.processor_ptr) + + if idle_root != 0x0 or active_root != 0x0: + self.print_processor('Name', 'Status', 'Pending Yield', 'Address') + self.iterate_procs(active_root, True) + self.iterate_procs(idle_root, False) + else: + print("No processors on cluster") + + print() ############ class Threads(gdb.Command): - """Cforall: Display currently known threads + """Cforall: Display currently known threads Usage: - cfathreads : print Main Cluster threads, application threads only - cfathreads all : print all clusters, all threads - cfathreads : print cluster threads, application threads only - """ - def __init__(self): - # The first parameter of the line below is the name of the command. You - # can call it 'uc++ task' - super(Threads, self).__init__('info cfathreads', gdb.COMMAND_USER) - - def print_formatted(self, marked, tid, name, state, address): - print('{:>1} {:>4} {:>20} {:>10} {:>20}'.format('*' if marked else ' ', tid, name, state, address)) - - def print_thread(self, thread, tid, marked): - cfa_t = get_cfa_types() - self.print_formatted(marked, tid, thread['self_cor']['name'].string(), str(thread['state'].cast(cfa_t.thread_state)), str(thread)) - - def print_formatted_cluster(self, str_format, cluster_name, cluster_addr): - print(str_format.format(cluster_name, cluster_addr)) - - def print_threads_by_cluster(self, cluster, print_system = False): - # Iterate through a circular linked list of tasks and print out its - # name along with address associated to each cluster - threads = lookup_threads_by_cluster(cluster) - if not threads: - return - - running_thread = find_curr_thread() - if running_thread is None: - print('Could not identify current thread') - - self.print_formatted(False, '', 'Name', 'State', 'Address') - - for t in threads: - if not t.is_system() or print_system: - self.print_thread(t.value, t.tid, t.value == running_thread if running_thread else False) - - print() - - def print_all_threads(self): - print("Not implemented") - - def invoke(self, arg, from_tty): - """ - @arg: str - @from_tty: bool - """ - if not is_cforall(): - return - - if not arg: - cluster = lookup_cluster() - if not cluster: - print("Could not find Main Cluster") - return - - # only tasks and main - self.print_threads_by_cluster(cluster, False) - - elif arg == 'all': - # all threads, all clusters - self.print_all_threads() - - else: - cluster = lookup_cluster(arg) - if not cluster: - print("Could not find cluster '{}'".format(arg)) - return - - # all tasks, specified cluster - self.print_threads_by_cluster(cluster, True) + cfathreads : print Main Cluster threads, application threads only + cfathreads all : print all clusters, all threads + cfathreads : print cluster threads, application threads only + """ + def __init__(self): + # The first parameter of the line below is the name of the command. You + # can call it 'uc++ task' + super(Threads, self).__init__('info cfathreads', gdb.COMMAND_USER) + + def print_formatted(self, marked, tid, name, state, address): + print('{:>1} {:>4} {:>20} {:>10} {:>20}'.format('*' if marked else ' ', tid, name, state, address)) + + def print_thread(self, thread, tid, marked): + cfa_t = get_cfa_types() + self.print_formatted(marked, tid, thread['self_cor']['name'].string(), str(thread['state'].cast(cfa_t.thread_state)), str(thread)) + + def print_threads_by_cluster(self, cluster, print_system = False): + # Iterate through a circular linked list of tasks and print out its + # name along with address associated to each cluster + threads = lookup_threads_by_cluster(cluster) + if not threads: + return + + running_thread = find_curr_thread() + if running_thread is None: + print('Could not identify current thread') + + self.print_formatted(False, '', 'Name', 'State', 'Address') + + for t in threads: + if not t.is_system() or print_system: + self.print_thread(t.value, t.tid, t.value == running_thread if running_thread else False) + + print() + + def print_all_threads(self): + for c in all_clusters(): + self.print_threads_by_cluster(c, False) + + def invoke(self, arg, from_tty): + """ + @arg: str + @from_tty: bool + """ + if not is_cforall(): + return + + if not arg: + cluster = lookup_cluster() + if not cluster: + print("Could not find Main Cluster") + return + + # only tasks and main + self.print_threads_by_cluster(cluster, False) + + elif arg == 'all': + # all threads, all clusters + self.print_all_threads() + + else: + cluster = lookup_cluster(arg) + if not cluster: + print("Could not find cluster '{}'".format(arg)) + return + + # all tasks, specified cluster + self.print_threads_by_cluster(cluster, True) ############ class Thread(gdb.Command): - def __init__(self): - # The first parameter of the line below is the name of the command. You - # can call it 'uc++ task' - super(Threads, self).__init__('cfathread', gdb.COMMAND_USER) - - def print_usage(self): - print_usage(""" - cfathread : print userCluster tasks, application tasks only - cfathread : print cluster tasks, application tasks only - cfathread all : print all clusters, all tasks - cfathread : switch stack to thread id on userCluster - cfathread 0x
: switch stack to thread on any cluster - cfathread : switch stack to thread on specified cluster - """) - - ############################ AUXILIARY FUNCTIONS ######################### - - def print_formatted(self, marked, tid, name, state, address): - print('{:>1} {:>4} {:>20} {:>10} {:>20}'.format('*' if marked else ' ', tid, name, state, address)) - - def print_thread(self, thread, tid, marked): - cfa_t = get_cfa_types() - self.print_formatted(marked, tid, thread['self_cor']['name'].string(), str(thread['state'].cast(cfa_t.thread_state)), str(thread)) - - def print_formatted_cluster(self, str_format, cluster_name, cluster_addr): - print(str_format.format(cluster_name, cluster_addr)) - - def print_tasks_by_cluster_all(self, cluster_address): - """ - Display a list of all info about all available tasks on a particular cluster - @cluster_address: gdb.Value - """ - cluster_address = cluster_address.cast(uCPPTypes.ucluster_ptr) - task_root = cluster_address['tasksOnCluster']['root'] - - if task_root == 0x0 or task_root.address == 0x0: - print('There are no tasks for cluster at address: {}'.format(cluster_address)) - return - - self.print_formatted_task('', 'Task Name', 'Address', 'State') - curr = task_root - task_id = 0 - systask_id = -1 - - breakpoint_addr = self.find_curr_breakpoint_addr() - if breakpoint_addr is None: - return - - while True: - global SysTask_Name - if (curr['task_']['name'].string() in SysTask_Name): - self.print_formatted_tasks(systask_id, breakpoint_addr, curr) - systask_id -= 1 - else: - self.print_formatted_tasks(task_id, breakpoint_addr, curr) - task_id += 1 - - curr = curr['next'].cast(uCPPTypes.uBaseTaskDL_ptr_type) - if curr == task_root: - break - - def print_tasks_by_cluster_address_all(self, cluster_address): - """ - Display a list of all info about all available tasks on a particular cluster - @cluster_address: str - """ - # Iterate through a circular linked list of tasks and print out its - # name along with address associated to each cluster - - # convert hex string to hex number - try: - hex_addr = int(cluster_address, 16) - except: - self.print_usage() - return - - cluster_address = gdb.Value(hex_addr) - if not self.print_tasks_by_cluster_all(cluster_address): - return - - def print_threads_by_cluster(self, cluster, print_system = False): - """ - Display a list of limited info about all available threads on a particular cluster - @cluster: str - @print_system: bool - """ - # Iterate through a circular linked list of tasks and print out its - # name along with address associated to each cluster - - threads = self.threads_by_cluster(cluster) - if not threads: - return - - running_thread = self.find_curr_thread() - if running_thread is None: - print('Could not identify current thread') - - self.print_formatted(False, '', 'Name', 'State', 'Address') - - for t in threads: - if not t.is_system() or print_system: - self.print_thread(t.value, t.tid, t.value == running_thread if running_thread else False) - - print() - - ############################ COMMAND FUNCTIONS ######################### - - def print_all_threads(self): - """Iterate through each cluster, iterate through all tasks and print out info about all the tasks - in those clusters""" - uCPPTypes = None - try: - uCPPTypes = get_uCPP_types() - except gdb.error: - print(not_supported_error_msg) - print(gdb.error) - return - - cluster_root = get_cluster_root() - if cluster_root.address == 0x0: - return - - curr = cluster_root - self.print_formatted_cluster(self.cluster_str_format, 'Cluster Name', 'Address') - - while True: - addr = str(curr['cluster_'].reference_value())[1:] - self.print_formatted_cluster(self.cluster_str_format, curr['cluster_']['name'].string(), addr) - - self.print_tasks_by_cluster_address_all(addr) - curr = curr['next'].cast(uCPPTypes.uClusterDL_ptr_type) - if curr == cluster_root: - break - - def switchto(self, thread): - """Change to a new task by switching to a different stack and manually - adjusting sp, fp and pc - @task_address: str - 2 supported format: - in hex format - : literal hexadecimal address - Ex: 0xffffff - in name of the pointer to the task - "task_name": pointer of the variable name of the cluster - Ex: T* s -> task_name = s - Return: gdb.value of the cluster's address - """ - # uCPPTypes = None - # try: - # uCPPTypes = get_uCPP_types() - # except gdb.error: - # print(not_supported_error_msg) - # print(gdb.error) - # return - - # # Task address has a format "task_address", which implies that it is the - # # name of the variable, and it needs to be evaluated - # if task_address.startswith('"') and task_address.endswith('"'): - # task = gdb.parse_and_eval(task_address.replace('"', '')) - # else: - # # Task address format does not include the quotation marks, which implies - # # that it is a hex address - # # convert hex string to hex number - # try: - # hex_addr = int(task_address, 16) - # except: - # self.print_usage() - # return - # task_address = gdb.Value(hex_addr) - # task = task_address.cast(uCPPTypes.uBaseTask_ptr_type) - try: - if not gdb.lookup_symbol('__cfactx_switch'): - print('__cfactx_switch symbol is unavailable') - return - except: - print('here 3') - - cfa_t = get_cfa_types() - - state = thread['state'].cast(cfa_t.thread_state) - try: - if state == gdb.parse_and_eval('Halted'): - print('Cannot switch to a terminated thread') - return - - if state == gdb.parse_and_eval('Start'): - print('Cannjot switch to a thread not yet run') - return - except: - print("here 2") - return - - - context = thread['context'] - - # lookup for sp,fp and uSwitch - xsp = context['SP'] + 48 - xfp = context['FP'] - - # convert string so we can strip out the address - try: - xpc = get_addr(gdb.parse_and_eval('__cfactx_switch').address + 28) - except: - print("here") - return - - # must be at frame 0 to set pc register - gdb.execute('select-frame 0') - - # push sp, fp, pc into a global stack - global STACK - sp = gdb.parse_and_eval('$sp') - fp = gdb.parse_and_eval('$fp') - pc = gdb.parse_and_eval('$pc') - stack_info = StackInfo(sp = sp, fp = fp, pc = pc) - STACK.append(stack_info) - - # update registers for new task - print('switching to ') - gdb.execute('set $rsp={}'.format(xsp)) - gdb.execute('set $rbp={}'.format(xfp)) - gdb.execute('set $pc={}'.format(xpc)) - - def find_matching_gdb_thread_id(): - """ - Parse the str from info thread to get the number - """ - info_thread_str = gdb.execute('info thread', to_string=True).splitlines() - for thread_str in info_thread_str: - if thread_str.find('this={}'.format(task)) != -1: - thread_id_pattern = r'^\*?\s+(\d+)\s+Thread' - # retrive gdb thread id - return re.match(thread_id_pattern, thread_str).group(1) - - # check if the task is running or not - if task_state == gdb.parse_and_eval('uBaseTask::Running'): - # find the equivalent thread from info thread - gdb_thread_id = find_matching_gdb_thread_id() - if gdb_thread_id is None: - print('cannot find the thread id to switch to') - return - # switch to that thread based using thread command - gdb.execute('thread {}'.format(gdb_thread_id)) - - def switchto_id(self, tid, cluster): - """ - @cluster: cluster object - @tid: int - """ - threads = self.threads_by_cluster( cluster ) - - for t in threads: - if t.tid == tid: - self.switchto(t.value) - return - - print("Cound not find thread by id '{}'".format(tid)) - - def invoke(self, arg, from_tty): - """ - @arg: str - @from_tty: bool - """ - if not is_cforall(): - return - - argv = parse(arg) - print(argv) - if len(argv) == 0: - """ - Iterate only Main Thread, print only tasks and main - """ - cluster = lookup_cluster() - if not cluster: - print("Could not find Main Cluster") - return - - # only tasks and main - self.print_threads_by_cluster(cluster, False) - - elif len(argv) == 1: - if argv[0] == 'help': - self.print_usage() - # push task - elif argv[0].isdigit(): - cluster = lookup_cluster() - if not cluster: - print("Could not find Main Cluster") - return - - try: - tid = int(argv[0]) - except: - print("'{}' not a valid thread id".format(argv[0])) - self.print_usage() - return - - # by id, userCluster - self.switchto_id(tid, cluster) - - elif argv[0].startswith('0x') or argv[0].startswith('0X'): - self.switchto(argv[0]) # by address, any cluster - # print tasks - elif argv[0] == 'all': - self.print_all_threads() # all tasks, all clusters - else: - """ - Print out all the tasks available in the specified cluster - @cluster_name: str - """ - print("cfathread by name") - cluster = lookup_cluster(argv[0]) - if not cluster: - return - - # all tasks, specified cluster - self.print_threads_by_cluster(cluster, True) - - elif len(argv) == 2: - # push task - self.pushtask_by_id(argv[0], argv[1]) # by id, specified cluster - else: - print('Invalid arguments') - self.print_usage() + """Cforall: Switch to specified user threads +Usage: + cfathread : switch stack to thread id on main cluster + cfathread 0x
: switch stack to thread on any cluster + cfathread : switch stack to thread on specified cluster + """ + def __init__(self): + # The first parameter of the line below is the name of the command. You + # can call it 'uc++ task' + super(Thread, self).__init__('cfathread', gdb.COMMAND_USER) + + ############################ AUXILIARY FUNCTIONS ######################### + + def switchto(self, thread): + """Change to a new task by switching to a different stack and manually + adjusting sp, fp and pc + @task_address: str + 2 supported format: + in hex format + : literal hexadecimal address + Ex: 0xffffff + in name of the pointer to the task + "task_name": pointer of the variable name of the cluster + Ex: T* s -> task_name = s + Return: gdb.value of the cluster's address + """ + try: + if not gdb.lookup_symbol('__cfactx_switch'): + print('__cfactx_switch symbol is unavailable') + return + except: + print('here 3') + + cfa_t = get_cfa_types() + + state = thread['state'].cast(cfa_t.thread_state) + try: + if state == gdb.parse_and_eval('Halted'): + print('Cannot switch to a terminated thread') + return + + if state == gdb.parse_and_eval('Start'): + print('Cannjot switch to a thread not yet run') + return + except: + print("here 2") + return + + + context = thread['context'] + + # lookup for sp,fp and uSwitch + xsp = context['SP'] + 48 + xfp = context['FP'] + + # convert string so we can strip out the address + try: + xpc = get_addr(gdb.parse_and_eval('__cfactx_switch').address + 28) + except: + print("here") + return + + # must be at frame 0 to set pc register + gdb.execute('select-frame 0') + + # push sp, fp, pc into a global stack + global STACK + sp = gdb.parse_and_eval('$sp') + fp = gdb.parse_and_eval('$fp') + pc = gdb.parse_and_eval('$pc') + stack_info = StackInfo(sp = sp, fp = fp, pc = pc) + STACK.append(stack_info) + + # update registers for new task + print('switching to ') + gdb.execute('set $rsp={}'.format(xsp)) + gdb.execute('set $rbp={}'.format(xfp)) + gdb.execute('set $pc={}'.format(xpc)) + + def find_matching_gdb_thread_id(): + """ + Parse the str from info thread to get the number + """ + info_thread_str = gdb.execute('info thread', to_string=True).splitlines() + for thread_str in info_thread_str: + if thread_str.find('this={}'.format(task)) != -1: + thread_id_pattern = r'^\*?\s+(\d+)\s+Thread' + # retrive gdb thread id + return re.match(thread_id_pattern, thread_str).group(1) + + # check if the task is running or not + if task_state == gdb.parse_and_eval('uBaseTask::Running'): + # find the equivalent thread from info thread + gdb_thread_id = find_matching_gdb_thread_id() + if gdb_thread_id is None: + print('cannot find the thread id to switch to') + return + # switch to that thread based using thread command + gdb.execute('thread {}'.format(gdb_thread_id)) + + def switchto_id(self, tid, cluster): + """ + @cluster: cluster object + @tid: int + """ + threads = lookup_threads_by_cluster( cluster ) + + for t in threads: + if t.tid == tid: + self.switchto(t.value) + return + + print("Cound not find thread by id '{}'".format(tid)) + + def invoke(self, arg, from_tty): + """ + @arg: str + @from_tty: bool + """ + if not is_cforall(): + return + + argv = parse(arg) + print(argv) + if argv[0].isdigit(): + cname = " ".join(argv[1:]) if len(argv) > 1 else None + cluster = lookup_cluster(cname) + if not cluster: + print("Could not find cluster '{}'".format(cname if cname else "Main Cluster")) + return + + try: + tid = int(argv[0]) + except: + print("'{}' not a valid thread id".format(argv[0])) + print_usage(self) + return + + # by id, userCluster + self.switchto_id(tid, cluster) + + elif argv[0].startswith('0x') or argv[0].startswith('0X'): + self.switchto(argv[0]) # by address, any cluster ############ class PrevThread(gdb.Command): - """Switch back to previous task on the stack""" - usage_msg = 'prevtask' - - def __init__(self): - super(PrevThread, self).__init__('prevtask', gdb.COMMAND_USER) - - def invoke(self, arg, from_tty): - """ - @arg: str - @from_tty: bool - """ - global STACK - if len(STACK) != 0: - # must be at frame 0 to set pc register - gdb.execute('select-frame 0') - - # pop stack - stack_info = STACK.pop() - pc = get_addr(stack_info.pc) - sp = stack_info.sp - fp = stack_info.fp - - # pop sp, fp, pc from global stack - adjust_stack(pc, fp, sp) - - # must be at C++ frame to access C++ vars - gdb.execute('frame 1') - else: - print('empty stack') + """Switch back to previous task on the stack""" + usage_msg = 'prevtask' + + def __init__(self): + super(PrevThread, self).__init__('prevtask', gdb.COMMAND_USER) + + def invoke(self, arg, from_tty): + """ + @arg: str + @from_tty: bool + """ + global STACK + if len(STACK) != 0: + # must be at frame 0 to set pc register + gdb.execute('select-frame 0') + + # pop stack + stack_info = STACK.pop() + pc = get_addr(stack_info.pc) + sp = stack_info.sp + fp = stack_info.fp + + # pop sp, fp, pc from global stack + adjust_stack(pc, fp, sp) + + # must be at C++ frame to access C++ vars + gdb.execute('frame 1') + else: + print('empty stack') class ResetOriginFrame(gdb.Command): - """Reset to the origin frame prior to continue execution again""" - usage_msg = 'resetOriginFrame' - def __init__(self): - super(ResetOriginFrame, self).__init__('reset', gdb.COMMAND_USER) - - def invoke(self, arg, from_tty): - """ - @arg: str - @from_tty: bool - """ - global STACK - if len(STACK) != 0: - stack_info = STACK.pop(0) - STACK.clear() - pc = get_addr(stack_info.pc) - sp = stack_info.sp - fp = stack_info.fp - - # pop sp, fp, pc from global stack - adjust_stack(pc, fp, sp) - - # must be at C++ frame to access C++ vars - gdb.execute('frame 1') - #else: - #print('reset: empty stack') #probably does not have to print msg + """Reset to the origin frame prior to continue execution again""" + usage_msg = 'resetOriginFrame' + def __init__(self): + super(ResetOriginFrame, self).__init__('reset', gdb.COMMAND_USER) + + def invoke(self, arg, from_tty): + """ + @arg: str + @from_tty: bool + """ + global STACK + if len(STACK) != 0: + stack_info = STACK.pop(0) + STACK.clear() + pc = get_addr(stack_info.pc) + sp = stack_info.sp + fp = stack_info.fp + + # pop sp, fp, pc from global stack + adjust_stack(pc, fp, sp) + + # must be at C++ frame to access C++ vars + gdb.execute('frame 1') + #else: + #print('reset: empty stack') #probably does not have to print msg Clusters() @@ -762,4 +599,5 @@ PrevThread() Threads() +Thread() # Local Variables: #