diff --git a/combination.h b/combination.h
index a20cc7d81c2d8169edde45a2fd17813f3f0bf57d..7bd74adcb3a229ea7b3f77c817f60eab8d37f503 100644
--- a/combination.h
+++ b/combination.h
@@ -21,7 +21,7 @@
#define _FX_DOUBLE 10
#define _FX_LONGLONG 11
-#define _FX_SYSTEM 1
+#define _FX_SYSTEM 6
#define _FX_CALCULATION_TYPE 11
#if _FX_SYSTEM == _FX_S1516 || _FX_SYSTEM == _FX_S1615 || _FX_SYSTEM == _FX_S2308
@@ -164,4 +164,4 @@
// #define fx_log(a, b) a
// #define fx_sin(a) a
-// #define fx_sqrt(a, b) a
\ No newline at end of file
+// #define fx_sqrt(a, b) a
diff --git a/fx_s1516_longlong_div_test.txt b/fx_s1516_longlong_div_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..afb5fda5d86ad4bbd492f0832b907cc18f958301
--- /dev/null
+++ b/fx_s1516_longlong_div_test.txt
@@ -0,0 +1,208 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 16.68 0.05 0.05 10000001 5.01 5.01 fx_s1516_longlong_mul4
+ 13.35 0.09 0.04 10000000 4.00 6.51 fx_mul1_test
+ 13.35 0.13 0.04 10000000 4.00 7.01 fx_mul3_test
+ 13.35 0.17 0.04 main
+ 10.01 0.20 0.03 10000001 3.00 3.00 fx_s1516_longlong_mul2
+ 8.34 0.23 0.03 10000001 2.50 2.50 fx_s1516_longlong_mul0
+ 8.34 0.25 0.03 10000001 2.50 2.50 fx_s1516_longlong_mul1
+ 6.67 0.27 0.02 10000000 2.00 4.50 fx_mul2_test
+ 5.01 0.29 0.02 10000001 1.50 1.50 fx_s1516_longlong_mul3
+ 3.34 0.30 0.01 10000000 1.00 2.50 fx_mul4_test
+ 1.67 0.30 0.01 fx_s1516_to_longlong
+ 0.00 0.30 0.00 10000000 0.00 5.01 fx_mul5_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 3.33% of 0.30 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 98.3 0.04 0.26 main [1]
+ 0.04 0.03 10000000/10000000 fx_mul3_test [2]
+ 0.04 0.03 10000000/10000000 fx_mul1_test [3]
+ 0.00 0.05 10000000/10000000 fx_mul5_test [5]
+ 0.02 0.03 10000000/10000000 fx_mul2_test [6]
+ 0.01 0.02 10000000/10000000 fx_mul4_test [10]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul4 [4]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul2 [7]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul0 [8]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul1 [9]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul3 [11]
+-----------------------------------------------
+ 0.04 0.03 10000000/10000000 main [1]
+[2] 23.3 0.04 0.03 10000000 fx_mul3_test [2]
+ 0.03 0.00 10000000/10000001 fx_s1516_longlong_mul2 [7]
+-----------------------------------------------
+ 0.04 0.03 10000000/10000000 main [1]
+[3] 21.7 0.04 0.03 10000000 fx_mul1_test [3]
+ 0.03 0.00 10000000/10000001 fx_s1516_longlong_mul0 [8]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.05 0.00 10000000/10000001 fx_mul5_test [5]
+[4] 16.7 0.05 0.00 10000001 fx_s1516_longlong_mul4 [4]
+-----------------------------------------------
+ 0.00 0.05 10000000/10000000 main [1]
+[5] 16.7 0.00 0.05 10000000 fx_mul5_test [5]
+ 0.05 0.00 10000000/10000001 fx_s1516_longlong_mul4 [4]
+-----------------------------------------------
+ 0.02 0.03 10000000/10000000 main [1]
+[6] 15.0 0.02 0.03 10000000 fx_mul2_test [6]
+ 0.03 0.00 10000000/10000001 fx_s1516_longlong_mul1 [9]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.03 0.00 10000000/10000001 fx_mul3_test [2]
+[7] 10.0 0.03 0.00 10000001 fx_s1516_longlong_mul2 [7]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.03 0.00 10000000/10000001 fx_mul1_test [3]
+[8] 8.3 0.03 0.00 10000001 fx_s1516_longlong_mul0 [8]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.03 0.00 10000000/10000001 fx_mul2_test [6]
+[9] 8.3 0.03 0.00 10000001 fx_s1516_longlong_mul1 [9]
+-----------------------------------------------
+ 0.01 0.02 10000000/10000000 main [1]
+[10] 8.3 0.01 0.02 10000000 fx_mul4_test [10]
+ 0.02 0.00 10000000/10000001 fx_s1516_longlong_mul3 [11]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.02 0.00 10000000/10000001 fx_mul4_test [10]
+[11] 5.0 0.02 0.00 10000001 fx_s1516_longlong_mul3 [11]
+-----------------------------------------------
+ <spontaneous>
+[12] 1.7 0.01 0.00 fx_s1516_to_longlong [12]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [3] fx_mul1_test [5] fx_mul5_test [11] fx_s1516_longlong_mul3
+ [6] fx_mul2_test [8] fx_s1516_longlong_mul0 [4] fx_s1516_longlong_mul4
+ [2] fx_mul3_test [9] fx_s1516_longlong_mul1 [12] fx_s1516_to_longlong
+ [10] fx_mul4_test [7] fx_s1516_longlong_mul2 [1] main
diff --git a/fx_s1516_longlong_mul_test.txt b/fx_s1516_longlong_mul_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..afb5fda5d86ad4bbd492f0832b907cc18f958301
--- /dev/null
+++ b/fx_s1516_longlong_mul_test.txt
@@ -0,0 +1,208 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 16.68 0.05 0.05 10000001 5.01 5.01 fx_s1516_longlong_mul4
+ 13.35 0.09 0.04 10000000 4.00 6.51 fx_mul1_test
+ 13.35 0.13 0.04 10000000 4.00 7.01 fx_mul3_test
+ 13.35 0.17 0.04 main
+ 10.01 0.20 0.03 10000001 3.00 3.00 fx_s1516_longlong_mul2
+ 8.34 0.23 0.03 10000001 2.50 2.50 fx_s1516_longlong_mul0
+ 8.34 0.25 0.03 10000001 2.50 2.50 fx_s1516_longlong_mul1
+ 6.67 0.27 0.02 10000000 2.00 4.50 fx_mul2_test
+ 5.01 0.29 0.02 10000001 1.50 1.50 fx_s1516_longlong_mul3
+ 3.34 0.30 0.01 10000000 1.00 2.50 fx_mul4_test
+ 1.67 0.30 0.01 fx_s1516_to_longlong
+ 0.00 0.30 0.00 10000000 0.00 5.01 fx_mul5_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 3.33% of 0.30 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 98.3 0.04 0.26 main [1]
+ 0.04 0.03 10000000/10000000 fx_mul3_test [2]
+ 0.04 0.03 10000000/10000000 fx_mul1_test [3]
+ 0.00 0.05 10000000/10000000 fx_mul5_test [5]
+ 0.02 0.03 10000000/10000000 fx_mul2_test [6]
+ 0.01 0.02 10000000/10000000 fx_mul4_test [10]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul4 [4]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul2 [7]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul0 [8]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul1 [9]
+ 0.00 0.00 1/10000001 fx_s1516_longlong_mul3 [11]
+-----------------------------------------------
+ 0.04 0.03 10000000/10000000 main [1]
+[2] 23.3 0.04 0.03 10000000 fx_mul3_test [2]
+ 0.03 0.00 10000000/10000001 fx_s1516_longlong_mul2 [7]
+-----------------------------------------------
+ 0.04 0.03 10000000/10000000 main [1]
+[3] 21.7 0.04 0.03 10000000 fx_mul1_test [3]
+ 0.03 0.00 10000000/10000001 fx_s1516_longlong_mul0 [8]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.05 0.00 10000000/10000001 fx_mul5_test [5]
+[4] 16.7 0.05 0.00 10000001 fx_s1516_longlong_mul4 [4]
+-----------------------------------------------
+ 0.00 0.05 10000000/10000000 main [1]
+[5] 16.7 0.00 0.05 10000000 fx_mul5_test [5]
+ 0.05 0.00 10000000/10000001 fx_s1516_longlong_mul4 [4]
+-----------------------------------------------
+ 0.02 0.03 10000000/10000000 main [1]
+[6] 15.0 0.02 0.03 10000000 fx_mul2_test [6]
+ 0.03 0.00 10000000/10000001 fx_s1516_longlong_mul1 [9]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.03 0.00 10000000/10000001 fx_mul3_test [2]
+[7] 10.0 0.03 0.00 10000001 fx_s1516_longlong_mul2 [7]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.03 0.00 10000000/10000001 fx_mul1_test [3]
+[8] 8.3 0.03 0.00 10000001 fx_s1516_longlong_mul0 [8]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.03 0.00 10000000/10000001 fx_mul2_test [6]
+[9] 8.3 0.03 0.00 10000001 fx_s1516_longlong_mul1 [9]
+-----------------------------------------------
+ 0.01 0.02 10000000/10000000 main [1]
+[10] 8.3 0.01 0.02 10000000 fx_mul4_test [10]
+ 0.02 0.00 10000000/10000001 fx_s1516_longlong_mul3 [11]
+-----------------------------------------------
+ 0.00 0.00 1/10000001 main [1]
+ 0.02 0.00 10000000/10000001 fx_mul4_test [10]
+[11] 5.0 0.02 0.00 10000001 fx_s1516_longlong_mul3 [11]
+-----------------------------------------------
+ <spontaneous>
+[12] 1.7 0.01 0.00 fx_s1516_to_longlong [12]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [3] fx_mul1_test [5] fx_mul5_test [11] fx_s1516_longlong_mul3
+ [6] fx_mul2_test [8] fx_s1516_longlong_mul0 [4] fx_s1516_longlong_mul4
+ [2] fx_mul3_test [9] fx_s1516_longlong_mul1 [12] fx_s1516_to_longlong
+ [10] fx_mul4_test [7] fx_s1516_longlong_mul2 [1] main
diff --git a/fx_s1615_longlong_div_test.txt b/fx_s1615_longlong_div_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..093518713f036abc8d3f930f5c49b3277757caac
--- /dev/null
+++ b/fx_s1615_longlong_div_test.txt
@@ -0,0 +1,161 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 45.52 0.05 0.05 10000000 5.01 5.01 fx_div3_test
+ 27.31 0.08 0.03 10000000 3.00 3.00 fx_div1_test
+ 9.10 0.09 0.01 10000000 1.00 1.00 fx_div2_test
+ 9.10 0.10 0.01 fx_mul3_test
+ 9.10 0.11 0.01 main
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 9.08% of 0.11 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 90.9 0.01 0.09 main [1]
+ 0.05 0.00 10000000/10000000 fx_div3_test [2]
+ 0.03 0.00 10000000/10000000 fx_div1_test [3]
+ 0.01 0.00 10000000/10000000 fx_div2_test [4]
+-----------------------------------------------
+ 0.05 0.00 10000000/10000000 main [1]
+[2] 45.5 0.05 0.00 10000000 fx_div3_test [2]
+-----------------------------------------------
+ 0.03 0.00 10000000/10000000 main [1]
+[3] 27.3 0.03 0.00 10000000 fx_div1_test [3]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[4] 9.1 0.01 0.00 10000000 fx_div2_test [4]
+-----------------------------------------------
+ <spontaneous>
+[5] 9.1 0.01 0.00 fx_mul3_test [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [3] fx_div1_test [2] fx_div3_test [1] main
+ [4] fx_div2_test [5] fx_mul3_test
diff --git a/fx_s1615_longlong_mul_test.txt b/fx_s1615_longlong_mul_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a038d7747e3443d16ca45821143d776d2f9e23e1
--- /dev/null
+++ b/fx_s1615_longlong_mul_test.txt
@@ -0,0 +1,161 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 32.19 0.05 0.05 10000000 4.51 4.51 fx_mul2_test
+ 21.46 0.08 0.03 frame_dummy
+ 17.88 0.10 0.03 10000000 2.50 2.50 fx_mul3_test
+ 14.31 0.12 0.02 10000000 2.00 2.00 fx_mul1_test
+ 14.31 0.14 0.02 main
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 7.13% of 0.14 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 78.6 0.02 0.09 main [1]
+ 0.05 0.00 10000000/10000000 fx_mul2_test [2]
+ 0.03 0.00 10000000/10000000 fx_mul3_test [4]
+ 0.02 0.00 10000000/10000000 fx_mul1_test [5]
+-----------------------------------------------
+ 0.05 0.00 10000000/10000000 main [1]
+[2] 32.1 0.05 0.00 10000000 fx_mul2_test [2]
+-----------------------------------------------
+ <spontaneous>
+[3] 21.4 0.03 0.00 frame_dummy [3]
+-----------------------------------------------
+ 0.03 0.00 10000000/10000000 main [1]
+[4] 17.9 0.03 0.00 10000000 fx_mul3_test [4]
+-----------------------------------------------
+ 0.02 0.00 10000000/10000000 main [1]
+[5] 14.3 0.02 0.00 10000000 fx_mul1_test [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [3] frame_dummy [2] fx_mul2_test [1] main
+ [5] fx_mul1_test [4] fx_mul3_test
diff --git a/fx_s2308_longlong_div_test.txt b/fx_s2308_longlong_div_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2eb1e3fe6390f92bb4bd8b717c9e7820cd738855
--- /dev/null
+++ b/fx_s2308_longlong_div_test.txt
@@ -0,0 +1,156 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 50.07 0.03 0.03 main
+ 16.69 0.04 0.01 10000000 1.00 1.00 fx_div1_test
+ 16.69 0.05 0.01 10000000 1.00 1.00 fx_div2_test
+ 16.69 0.06 0.01 fx_mul4_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 16.64% of 0.06 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 83.3 0.03 0.02 main [1]
+ 0.01 0.00 10000000/10000000 fx_div1_test [2]
+ 0.01 0.00 10000000/10000000 fx_div2_test [3]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[2] 16.7 0.01 0.00 10000000 fx_div1_test [2]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[3] 16.7 0.01 0.00 10000000 fx_div2_test [3]
+-----------------------------------------------
+ <spontaneous>
+[4] 16.7 0.01 0.00 fx_mul4_test [4]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [2] fx_div1_test [4] fx_mul4_test
+ [3] fx_div2_test [1] main
diff --git a/fx_s2308_longlong_mul_test.txt b/fx_s2308_longlong_mul_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e859e13f9c40b023480cde4f31e129493652ffb9
--- /dev/null
+++ b/fx_s2308_longlong_mul_test.txt
@@ -0,0 +1,162 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 54.62 0.06 0.06 10000000 6.01 6.01 fx_mul3_test
+ 27.31 0.09 0.03 main
+ 9.10 0.10 0.01 10000000 1.00 1.00 fx_mul4_test
+ 4.55 0.11 0.01 10000000 0.50 0.50 fx_mul1_test
+ 4.55 0.11 0.01 10000000 0.50 0.50 fx_mul2_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 9.08% of 0.11 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.03 0.08 main [1]
+ 0.06 0.00 10000000/10000000 fx_mul3_test [2]
+ 0.01 0.00 10000000/10000000 fx_mul4_test [3]
+ 0.01 0.00 10000000/10000000 fx_mul1_test [4]
+ 0.01 0.00 10000000/10000000 fx_mul2_test [5]
+-----------------------------------------------
+ 0.06 0.00 10000000/10000000 main [1]
+[2] 54.5 0.06 0.00 10000000 fx_mul3_test [2]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[3] 9.1 0.01 0.00 10000000 fx_mul4_test [3]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[4] 4.5 0.01 0.00 10000000 fx_mul1_test [4]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[5] 4.5 0.01 0.00 10000000 fx_mul2_test [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [4] fx_mul1_test [2] fx_mul3_test [1] main
+ [5] fx_mul2_test [3] fx_mul4_test
diff --git a/fx_s3132_longlong_div_test.txt b/fx_s3132_longlong_div_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..abeb851649be8d6b9c78663e1d12d561c5eca78f
--- /dev/null
+++ b/fx_s3132_longlong_div_test.txt
@@ -0,0 +1,157 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 37.55 0.03 0.03 10000000 3.00 3.00 fx_div1_test
+ 37.55 0.06 0.03 main
+ 12.52 0.07 0.01 10000000 1.00 1.00 fx_div2_test
+ 12.52 0.08 0.01 10000000 1.00 1.00 fx_div3_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 12.48% of 0.08 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.03 0.05 main [1]
+ 0.03 0.00 10000000/10000000 fx_div1_test [2]
+ 0.01 0.00 10000000/10000000 fx_div2_test [3]
+ 0.01 0.00 10000000/10000000 fx_div3_test [4]
+-----------------------------------------------
+ 0.03 0.00 10000000/10000000 main [1]
+[2] 37.5 0.03 0.00 10000000 fx_div1_test [2]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[3] 12.5 0.01 0.00 10000000 fx_div2_test [3]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[4] 12.5 0.01 0.00 10000000 fx_div3_test [4]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [2] fx_div1_test [4] fx_div3_test
+ [3] fx_div2_test [1] main
diff --git a/fx_s3132_longlong_mul_test.txt b/fx_s3132_longlong_mul_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1ff2c7f6ab975681e22d22944fde8a703328b6d4
--- /dev/null
+++ b/fx_s3132_longlong_mul_test.txt
@@ -0,0 +1,157 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 33.38 0.02 0.02 10000000 2.00 2.00 fx_mul1_test
+ 33.38 0.04 0.02 main
+ 16.69 0.05 0.01 10000000 1.00 1.00 fx_mul2_test
+ 16.69 0.06 0.01 10000000 1.00 1.00 fx_mul3_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 16.64% of 0.06 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.02 0.04 main [1]
+ 0.02 0.00 10000000/10000000 fx_mul1_test [2]
+ 0.01 0.00 10000000/10000000 fx_mul2_test [3]
+ 0.01 0.00 10000000/10000000 fx_mul3_test [4]
+-----------------------------------------------
+ 0.02 0.00 10000000/10000000 main [1]
+[2] 33.3 0.02 0.00 10000000 fx_mul1_test [2]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[3] 16.7 0.01 0.00 10000000 fx_mul2_test [3]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[4] 16.7 0.01 0.00 10000000 fx_mul3_test [4]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [2] fx_mul1_test [4] fx_mul3_test
+ [3] fx_mul2_test [1] main
diff --git a/fx_s3231_longlong_div_test.txt b/fx_s3231_longlong_div_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5501938cdda92578b380db9b4ffe5bdd23dd9864
--- /dev/null
+++ b/fx_s3231_longlong_div_test.txt
@@ -0,0 +1,161 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 30.81 0.04 0.04 10000000 4.01 4.01 fx_div3_test
+ 23.11 0.07 0.03 10000000 3.00 3.00 fx_div2_test
+ 23.11 0.10 0.03 main
+ 19.26 0.13 0.03 10000000 2.50 2.50 fx_div1_test
+ 3.85 0.13 0.01 fx_mul3_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 7.68% of 0.13 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 96.2 0.03 0.10 main [1]
+ 0.04 0.00 10000000/10000000 fx_div3_test [2]
+ 0.03 0.00 10000000/10000000 fx_div2_test [3]
+ 0.03 0.00 10000000/10000000 fx_div1_test [4]
+-----------------------------------------------
+ 0.04 0.00 10000000/10000000 main [1]
+[2] 30.8 0.04 0.00 10000000 fx_div3_test [2]
+-----------------------------------------------
+ 0.03 0.00 10000000/10000000 main [1]
+[3] 23.1 0.03 0.00 10000000 fx_div2_test [3]
+-----------------------------------------------
+ 0.03 0.00 10000000/10000000 main [1]
+[4] 19.2 0.03 0.00 10000000 fx_div1_test [4]
+-----------------------------------------------
+ <spontaneous>
+[5] 3.8 0.01 0.00 fx_mul3_test [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [4] fx_div1_test [2] fx_div3_test [1] main
+ [3] fx_div2_test [5] fx_mul3_test
diff --git a/fx_s3231_longlong_mul_test.txt b/fx_s3231_longlong_mul_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9a18796ba3b04ef8da4c0f0a9ac5bf4d9ac60120
--- /dev/null
+++ b/fx_s3231_longlong_mul_test.txt
@@ -0,0 +1,161 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 50.06 0.05 0.05 main
+ 20.03 0.07 0.02 10000000 2.00 2.00 fx_mul1_test
+ 15.02 0.09 0.02 10000000 1.50 1.50 fx_mul2_test
+ 10.01 0.10 0.01 10000000 1.00 1.00 fx_mul3_test
+ 5.01 0.10 0.01 fx_div1_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 9.99% of 0.10 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 95.0 0.05 0.05 main [1]
+ 0.02 0.00 10000000/10000000 fx_mul1_test [2]
+ 0.02 0.00 10000000/10000000 fx_mul2_test [3]
+ 0.01 0.00 10000000/10000000 fx_mul3_test [4]
+-----------------------------------------------
+ 0.02 0.00 10000000/10000000 main [1]
+[2] 20.0 0.02 0.00 10000000 fx_mul1_test [2]
+-----------------------------------------------
+ 0.02 0.00 10000000/10000000 main [1]
+[3] 15.0 0.02 0.00 10000000 fx_mul2_test [3]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[4] 10.0 0.01 0.00 10000000 fx_mul3_test [4]
+-----------------------------------------------
+ <spontaneous>
+[5] 5.0 0.01 0.00 fx_div1_test [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [5] fx_div1_test [3] fx_mul2_test [1] main
+ [2] fx_mul1_test [4] fx_mul3_test
diff --git a/fx_s4716_longlong_div_test.txt b/fx_s4716_longlong_div_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c32fc10d8dbec7142a12eb45bdf2442ef5720ca4
--- /dev/null
+++ b/fx_s4716_longlong_div_test.txt
@@ -0,0 +1,157 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 66.76 0.26 0.26 main
+ 17.97 0.33 0.07 10000000 7.01 7.01 fx_div1_test
+ 7.70 0.36 0.03 10000000 3.00 3.00 fx_div2_test
+ 7.70 0.39 0.03 10000000 3.00 3.00 fx_div3_test
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 2.56% of 0.39 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.26 0.13 main [1]
+ 0.07 0.00 10000000/10000000 fx_div1_test [2]
+ 0.03 0.00 10000000/10000000 fx_div2_test [3]
+ 0.03 0.00 10000000/10000000 fx_div3_test [4]
+-----------------------------------------------
+ 0.07 0.00 10000000/10000000 main [1]
+[2] 17.9 0.07 0.00 10000000 fx_div1_test [2]
+-----------------------------------------------
+ 0.03 0.00 10000000/10000000 main [1]
+[3] 7.7 0.03 0.00 10000000 fx_div2_test [3]
+-----------------------------------------------
+ 0.03 0.00 10000000/10000000 main [1]
+[4] 7.7 0.03 0.00 10000000 fx_div3_test [4]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [2] fx_div1_test [4] fx_div3_test
+ [3] fx_div2_test [1] main
diff --git a/fx_s4716_longlong_mul_test.txt b/fx_s4716_longlong_mul_test.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f106374476cd92aeeffb803f02319ed2c45a47dc
--- /dev/null
+++ b/fx_s4716_longlong_mul_test.txt
@@ -0,0 +1,161 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 50.07 0.06 0.06 main
+ 25.03 0.09 0.03 10000000 3.00 3.00 fx_mul2_test
+ 8.34 0.10 0.01 10000000 1.00 1.00 fx_mul1_test
+ 8.34 0.11 0.01 10000000 1.00 1.00 fx_mul3_test
+ 8.34 0.12 0.01 frame_dummy
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 8.32% of 0.12 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 91.7 0.06 0.05 main [1]
+ 0.03 0.00 10000000/10000000 fx_mul2_test [2]
+ 0.01 0.00 10000000/10000000 fx_mul1_test [3]
+ 0.01 0.00 10000000/10000000 fx_mul3_test [4]
+-----------------------------------------------
+ 0.03 0.00 10000000/10000000 main [1]
+[2] 25.0 0.03 0.00 10000000 fx_mul2_test [2]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[3] 8.3 0.01 0.00 10000000 fx_mul1_test [3]
+-----------------------------------------------
+ 0.01 0.00 10000000/10000000 main [1]
+[4] 8.3 0.01 0.00 10000000 fx_mul3_test [4]
+-----------------------------------------------
+ <spontaneous>
+[5] 8.3 0.01 0.00 frame_dummy [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [5] frame_dummy [2] fx_mul2_test [1] main
+ [3] fx_mul1_test [4] fx_mul3_test
diff --git a/test.c b/test.c
index a6c4cec7099c8a6beb0dc709563a0731d92ddf24..d98b340aea4e9223f01d9c3060fb4c509a47b292 100644
--- a/test.c
+++ b/test.c
@@ -333,9 +333,9 @@ int main(){
printf("MUL1: %d\n", fx_mul1(num1, num2));
printf("MUL2: %d\n", fx_mul2(num1, num2));
printf("MUL3: %d\n", fx_mul3(num1, num2));
- printf("MUL4: %d\n", fx_mul4(num1, num2));
- printf("MUL5: %d\n", fx_mul5(num1, num2));
#if _FX_SYSTEM == _FX_S1516 && _FX_CALCULATION_TYPE == _FX_LONGLONG
+ printf("MUL4: %d\n", fx_mul4(num1, num2));
+ printf("MUL5: %d\n", fx_mul5(num1, num2));
for(int i = 0 ; i < Max; i++){
fx_mul1_test(num1,num2);
}
@@ -833,4 +833,4 @@ int main(){
#endif
}
}
-}
\ No newline at end of file
+}