It's the Java GUI. It happens sometimes. I miss the Classic interface. Java could be nice for developers, but for users ... slow and buggy.

Here is a general solution.
Probably it cannot be accepted as a homework solution, but it's a good exercise for you to understand how it works (Maple+maths).

n:=4: # take n:=5 for your problem
f := ( 1 + a * mul(x-k, k=1..n) )/x:
f := unapply(simplify(eval(f,solve(eval(numer(f),x=0),{a}))), x):
seq( 'f'(k)=f(k), k=-1..7 );

       f(-1) = 4, f(0) = 25/12, f(1) = 1, f(2) = 1/2, f(3) = 1/3, f(4) = 1/4, f(5) = 0, f(6) = -2/3, f(7) = -2

For n = 34, R[n] alone is a rational number whose denominator has about 5*10^9 digits!

Are you sure you really want this?

You can use the explicit option in solve and avoid allvalues.

F := [x^2+y+z-1, y^2+x+z-1, z^2+x+y-1]:
Sol:=solve(F, explicit);
    Sol := {x = 0, y = 0, z = 1}, {x = 0, y = 1, z = 0}, {x = 1, y = 0, z = 0}, {x = 2^(1/2)-1, y = 2^(1/2)-1, z = 2^(1/2)-1}, {x = -1-2^(1/2), y = -1-2^(1/2), z = -1-2^(1/2)}
seq(simplify(eval(F,s)), s=Sol);
     [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]
# or ...
seq(simplify(subs(s,F)), s=Sol);
    [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]

If we insist on using LSystem, a more natural solution is:

restart;
with(Fractals:-LSystem): with(plots):
state:= "F-F-F":
cons:= proc(n)
  local x:=sprintf("%.10f",((1/3.)^n));
  [ "F"="draw:"||x, "+"="turn:-60", "-"="turn:-240" ]
end:
rules:= ["F"="F+F-F+F"]:
display(seq(LSystemPlot(Iterate(state, rules, n), cons(n))$4, n=0..6), insequence);

One obtains the same animation as in my first direct solution.

nextkoch:=(a,b)->
((2*a+b)/3, (2*a+b)/3+ (b-a)/3*evalf(exp(-Pi/3*I)), (a+2*b)/3):
L:=evalf([0,1,1/2+I*sqrt(3)/2,0]): N:=6: LL[0]:=L:
for j to N do
  L:=[ seq( [ L[i], nextkoch(L[i],L[i+1]) ][], i=1..nops(L)-1), L[-1] ]:
  LL[j]:=L;
od:
plots:-animate( plots:-complexplot, [LL[floor(n)]], n=0..N+.99, 
  scaling=constrained, axes=none, frames=4*(N+1), paraminfo=false);

The shape of a quadrilateral inscribed in the unit circle and having an inscribed circle.

f := (a,b) -> 1/2*(b+arccos(sin(2*a-b)/tan(b))):
dis:=(A,B)-> sqrt(inner(A-B,A-B)):
bisA:=proc(A,B,C)
  local b,c,M;
  b,c:=dis(A,C),dis(A,B);
  M:=(b*B+c*C)/(b+c);
  x*(A[2]-M[2])+y*(M[1]-A[1]) + A[1]*M[2]-A[2]*M[1]
end:
P:=proc(a0,b0)
  local a:=evalf(a0), b:=evalf(b0), c:=f(a,b), p1,p2,p3,p4, r, II;
  if a0>b0-0.001 then return plot() fi;
  p1,p2,p3,p4:=[1,0],[cos(4*a),sin(4*a)],[cos(4*b),sin(4*b)],[cos(4*c),sin(4*c)];
  II:= eval([x,y], solve( [bisA(p2,p1,p3), bisA(p3,p2,p4)]) );
  r:=evalf(eval(dis(II,p2)*cos(b))); 
  plots:-display(plot([p1,p2,p3,p4,p1]), plottools:-circle(II,r, color=blue), plottools:-circle([0,0],1));
end:
Explore(P(a,b), parameters=[a=0.01..Pi/2-0.02, b=0.02..Pi/2-0.01], initialvalues=[a=Pi/8,b=Pi/4]);

###    0 < a < b < Pi/2

restart;
PP:=proc(n::posint, kmin::posint, L::list(prime), nSolMax::posint)
# Prime partitions with elements >= kmin, starting with L
local Sol:=table(), nSol:=0, E;

E:=proc(L)
local p,sL:=add(L);
if L<>[] then p:=L[-1] else p:=nextprime(kmin-1) fi;
while p+sL<=n and nSol<=nSolMax do
  if p+sL=n and nSol<nSolMax then Sol[++nSol]:=[L[],p] fi;
  if nSol>=nSolMax then return fi;  
  E([L[],p]);
  p:=nextprime(p);
od;
end:

if L<>[] and add(L)=n then  Sol[++nSol]:=L fi;   
E(L);
entries(Sol,nolist);
end:

SingPrime:=proc(p::prime,n::posint)  
# there exist only 1 PP starting with p
evalb(nops([PP(n,p,[p],2)])=1)
end:

Q := proc(n)    # list of SingPrime's
local p, P:=select(isprime, [seq(1..n)]);
select(SingPrime, P, n)
end:

SingPrime(3,8), SingPrime(5,8);
                          true, false
for n from 2 to 500 do
    if Q(n)=[] then printf("%d ",n) fi
od;
63 161 195 235 253 425

(The procedures are not optimized.)

An implementation of Lehmer's algorithm.

Lpi := proc(x)  # Lehmer pi
  local phi, Lpi1, M:=10^7 ;
    
  phi := proc(x, a)
  local t;
  if a <= 1 then  return iquo(x + 1, 2) fi;
  t := thisproc(x, a-1) - thisproc(iquo(x, ithprime(a)), a-1);
  procname(x, a) := t;
  t;
  end;

  Lpi1 := proc(x)
  local a,b,c,s,w,i,j,L, xx:=trunc(x);
  if (trunc(x) < M) then return NumberTheory:-pi(x) fi;
  a := thisproc(iroot(xx, 4));;
  b := thisproc(isqrt(xx));
  c := thisproc(iroot(xx, 3));
  s := phi(xx,a) + (b+a-2) * (b-a+1) / 2;
  for i from a+1 to b do
    w := iquo(xx , ithprime(i));
    L := thisproc(isqrt(w));
    s := s - thisproc(w);
    if (i <= c) then
      for j from i to L do
        s := s - thisproc(iquo(w , ithprime(j))) + j - 1
      od
    fi
  od;
  s
  end;

Lpi1(x)
end:

CodeTools:-Usage(Lpi(6469693230));
memory used=6.11GiB, alloc change=80.00MiB, cpu time=55.19s, real time=50.11s, gc time=10.83s
                           300369796

Download IntEq-vv.mw

Use add instead of sum i.e.

c := k -> piecewise(k = 0,b(0)^N,1 <= k,1/k/b(0)*add((q*(N+1)-k)*b(q)*c(k-q),q = 1.. k));

restart: 
with(GraphTheory):
L:=ImportGraph("yourpath/graph5c.g6", graph6, output=list):
DrawGraph(L);

The integrals are highly oscillating. t1 is convergent but not absolutely (so it does not exist as a Lebesgue integral).
Maple needs help from the user for such integrals.
I doubt Maple V was able to calculate them directly (and correctly).

Here is a special method to compute t1 (t2 goes similarly).

restart;
f1:= unapply( eval((1-exp(-(d-y)*I*x))/I/x*exp(y*I*x/(1-I*x)),  [d=3, y=9/10]), x):
F1:= u -> f1(1/u)/u^2:
h := t -> t+I*t*(1-t): # special change of variables
G1:=unapply(simplify(F1(h(t))*D(h)(t)), t):
t1:=evalf[25](2*Int(Re@f1, 0..1) + 2*Int(Re@G1, 0 .. 1));

       t1 := 3.418878800322797147227936

Edit: added a forgotten term.