God is real . . . unless declared integer This challenge is inspired by Fortran's idiosyncratic implicit typing rules. Your task will be to determine the data type of the object GOD according to the implicit typing rules explained below.
Background
Fortran 77 has six data types: CHARACTER, COMPLEX, DOUBLE PRECISION, INTEGER, LOGICAL, and REAL. Any object not explicitly declared to have one of these types is implicitly assigned a type by the compiler, as determined by the first letter of the object's name. The default implicit types are:
----------------------------
First letter | Implicit type 
-------------+--------------
    A-H      |     REAL          
    I-N      |   INTEGER
    O-Z      |     REAL
----------------------------

For example, the object called NUMBER (first letter N) has implied type INTEGER whereas the object called DUMBER (first letter D) has implied type REAL. These rules lead to the old joke that GOD is REAL . . . unless declared INTEGER.
The default implicit types can be overridden using IMPLICIT statements. For example,
IMPLICIT DOUBLE PRECISION (D,X-Z), INTEGER (N-P)

means that all objects whose names start with D, X, Y, or Z now have implied type DOUBLE PRECISION and those starting with N, O, or P have implied type INTEGER. Objects whose names start with any other letter retain their default implied types (in this example, REAL for A–C, E–H, and Q–W and INTEGER for I–M).
For the purposes of this challenge, we will adopt a more concise syntax: the IMPLICIT keyword (redundant here) will be dropped and we will use the single-character identifiers C, D, I, L, R, and X to represent the six data types (X represents COMPLEX). Thus, the example IMPLICIT statement given above becomes
D(D,X-Z), I(N-P)

i.e. a series of identifier–range pairs.
The challenge
Assume that the object GOD exists in a Fortran 77 program and does not have an explicitly declared type. Write a program or function that returns the implied type of GOD, given a compact IMPLICIT statement as input. This is code-golf: the shortest submission (in bytes) in each language wins.
Input

Input is either empty or otherwise consists of 1 to 26 identifier–range pairs.
Input may be taken in any reasonable format (e.g. one long string, list of identifier–range pairs). If you divide the input into identifier–range pairs, each pair may either be taken as is, e.g. 'D(D,X-Z)', or split, e.g. ['D', '(D,X-Z)'].
In ranges, letters appear in alphabetical order and are separated either by commas (for single letters) or dashes (indicating a span of letters). One-letter spans, e.g. G-G, are valid. The outer parentheses must be included, but may be replaced with other paired delimiters (e.g. [] or {}) if desired.
IMPLICIT statements are guaranteed not to overlap. That is, no letter has its implied type specified more than once.
Alphabetic characters must be uppercase.

Output
The uppercase identifier, C, D, I, L, R, or X, that represents the implied type of the object GOD. If the input is empty, your code must return R (the default type of GOD).
Test cases
Input -&gt; Output
'' -&gt; R
I(M-Z) -&gt; R
I(A-Z) -&gt; I
I(G) -&gt; I
I(G-G) -&gt; I
L(A,B,D-H,M-X,Z) -&gt; L
D(D,X-Z), I(N-P) -&gt; R
L(B,D,F,H,J,L,N,P,R,T,V,X,Z), C(A,C,E,G,I,K,M,O,Q,S,U,W,Y) -&gt; C
D(S-Z), D(J-Q), D(A-H) -&gt; D
I(I-K,M,R-T), R(N-P,U-Z), D(D-F,H), X(C,G), C(A,B,Q), L(L) -&gt; X
I(F), X(N), R(P-P), I(C-C), C(A-A), I(J-J), R(V), D(H-H), X(O), L(B-B), C(R), L(Q-Q), I(D), L(X), R(S-S), C(Y), L(T-T), L(Z), X(U), D(K-K), R(G), X(W-W), D(I), C(L-L), R(E), I(M) -&gt; R

Note: In the first test case, single quotes denote string boundaries.
Bonus imaginary internet points!
Awarded to answers that only use characters from the standard Fortran 77 character set: the 26 uppercase letters A-Z, the 10 digits 0-9, the space  , and the 12 characters +-*/=().,’:$
FORTRAN IV (Compiled with gfortran -ffixed-form), 309 291 290 280 398 393 392 334 237 231 bytes + Bonus imaginary Internet points



This should now be a proper FORTRAN IV program, with no anachronisms!



&#9;REALS(200)
&#9;DATAG,R,H,A/1HG,1HR,1H-,1H(/
&#9;READ 9,S
    9&#9;FORMAT(200A1)
&#9;DO1 I=1,200
&#9;C=S(I)
&#9;IF(C.NE.A)GOTO2
&#9;T=S(I-1)
&#9;GOTO1
    2&#9;IF(C.LT.G.AND.S(I+1).EQ.H.AND.S(I+2).GE.G.OR.C.EQ.G)GOTO8
    1&#9;CONTINUE
&#9;T=R
    8&#9;PRINT 9,T
&#9;END


Try it online!

Here's the same code embedded in a loop that runs through the entire test suite.  I don't think this can be done with TIO's header and footer.



18 bytes off thanks to @JonathanAllan, who pointed out that one IF statement wasn't needed.

1 more byte off by eliminating a stray space between CHARACTER and S at the top.

And 10 more bytes by rearranging the spaghetti code a bit.

Added 118 bytes to put it in proper FORTRAN IV fixed-column punch-card formatting. (This is for historical accuracy -- it isn't necessary for proper functioning under gfortran.)

Shaved off 5 more bytes: Cleaned up the GOTOs a bit, and changed the treatment of characters so it's actually correct for FORTRAN IV.

1 more byte off from removing an unneeded space in the DATA statement.

58 bytes off by streamlining the flow of control through the various IF statements.

97 more bytes off by: (1) eliminating variable P; and (2) replacing the spaces required at the beginning of a line with a tab character, which I found is allowed, according to an old FORTRAN IV manual. (I was thinking of punch card machines, which, as I recall, didn't have a horizontal tab, but I forgot about teletype machines, which did have a tab key.)

Thanks to @Dingus for 6 more bytes (from removing the B in the DATA statement which was no longer needed after P was eliminated).



I've limited myself to FORTRAN IV constructs here.  This should now be a correct FORTRAN IV program, without such things as the CHARACTER data type and quote-delimited strings, which were only introduced later.  

Characters in FORTRAN IV needed to be entered as Hollerith constants, and they could be stored in variables of type REAL (and probably other types sometimes too, but there was no CHARACTER type originally).  (As I recall, a real could hold 5 ASCII characters from what we now call a string.  I think they were padded with spaces if there were fewer than 5 characters in a grouping.  The single characters I use are each stored as a real, padded with extra space characters in the real.)

Input is on stdin, on one line, just like the OP's test cases.

Output is on stdout.



FORTRAN IV was my introduction to computer programming -- it was the first programming language I ever learned.  When I was a boy, I read through my dad's textbooks when he took a class in it at NYU, which was required by his musicology graduate program.  Computer programming (as well as FORTRAN itself) has changed quite a bit since then :) .