Recently, I read an old article about how to call external subroutines to speed up the evaluation tremendously. The core of that article is: 

Evidently, the is equivalent to  when b＞0, and the  is equivalent to . 
The 𝙲 code in that article was composed separately. However, now that it is possible to generate external functions, compile and access them using a single Compiler:-Compile command, it is better to complete the entire process on the fly (in order to reduce oversights and typographical errors while coding). (Besides, the original 𝙼𝚊𝚙𝚕𝚎 implementation appears verbose and less elegant.) So I write: 

But unfortunately, I then get: 

JonesM1(1);
                               2

JonesM1(2);
                               3

JonesM1(3);
                               5

JonesM1(4);
Error, (in JonesM1) integer overflow detected in compiled code

How do I get rid of this error message? 

Note. Of course there exist a ready-to-use built-in function , but the chief aim is not to find the n-th prime number as quickly as possible; I want to see if 𝙼𝚊𝚙𝚕𝚎 can directly create a compiled version of the one-liner that implements the so-called Jones' algorithm instead of writing separate 𝙲 code like that article. (Don't confound the means with the ends.) 

The output  means that there is no real solution, but clearly, both and  satisfy the original equation: 

So, why does `solve` lose the real solutions without any warning messages? 
Code: 

restart;
eq := 9*(x^2 + 2*cos(x)) = Pi^2 + 9;
RealDomain:-solve(eq, [x]);
                               []

:-solve({eq, x >= 0}, [x]); # as (lhs - rhs)(eq) is an even function 
                               []

The first time they are evaluated, some aborts can occur; the second time they are evaluated, no exception is thrown: 
 

Download run__twice.mw

Why does (the outer) RootOf have to be evaluated twice? 
Note. There are other similar examples, but they are less concise (so they are omitted here).

I have a quite complex expression (where and are real numbers): 

According to coulditbe, is satisfiable: 

_EnvTry := 'hard':
coulditbe(expr) assuming real;
 = 
                              true

But according to SMTLIB:-Satisfiable, is not satisfiable: 

SMTLIB:-Satisfiable(expr) assuming real;
 = 
                             false

Why are the two results opposite? 

For reference, below is the output from RealDomain:-solve: 

RealDomain:-solve(expr);
 = 
               /           1  2\                 
              { p = p, q = - p  }, {p = p, q = 0}
               \           4   /                 

I also tried using RealDomain:-simplify, yet the output remains almost unchanged (Why?). 

A classic result states that the equation x³＋px²＋qx＋r＝0 with real coefficients p, q, r has positive roots iff p＜0, q＞0, r＜0 and -27r² - 2p(2p² - 9q)r + q²(p² - 4q) ⩾ 0 (see for example this question). 
However, Maple appears unable to find the condition: 

a, b, c := allvalues(RootOf(x^3 + p*x^2 + q*x + r, x), 'implicit'):
RealDomain:-solve({a, b, c} >~ 0, [p, q, r]);
 = 
Warning, solutions may have been lost
                               []

Is there a way to get the above conditions in Maple with as little human intervention as possible (I mean, without a priori knowledge of the theory of polynomials)? 

Edit. An interesting problem is when these three positive roots can further be the lengths of sides of a triangle. For reference, here are some (unenlightening) results from some other software: