National Scheduling Conflict Championships (I meant to post this while 1542: Scheduling Conflict
was still the current xkcd, but I had a scheduling conflict.)

Input

The input will be a list of 3n elements, which represent n events. The
first element in each group of 3 will be the name of an event; the second and
third, the start and end time respectively. For example:

foo 12 34 bar 56 78


represents an event foo that starts at "time 12" (times are represented
simply by integers; you can think of them as minutes past midnight) and ends at
34, and a second event bar that starts at 56 and ends at 78.

The names of events will always consist of only alphanumeric characters, and
the times will always be integers ≥ 0 and &lt; 1440. The end time will always be
at least 1 greater than the start time. They are not guaranteed to be sorted in
any way.

If you would like, you may take this as a single space-separated string;
otherwise it should be taken as an array, list, vector, or your language's
equivalent.

Output

The output should be a space-separated list of event names. The rules for which
event names to output are as follows:


None of the events that you output may conflict with each other. For example,
with the input a 0 10 b 5 15, you may not output both a and b because
the times conflict (that is, partially overlap). If an event ends exactly as
another one starts, you may include both.
You may not output the event called NSCC ("National Scheduling Conflict
Competition"), of which there will always be exactly one of in the input.
You also must output at least one event that conflicts (partially
overlaps) with NSCC (and there will always be at least one of those as
well).
You must output as many events as possible while following the above two
rules. (This is so that you look as busy as possible, so that missing the
NSCC seems more credible.)


This may also be output as either a single space-separated string or an array,
list, vector, etc.

There can be more than one possible output.

Test cases

Note that the outputs listed are only examples. Your code may output something
different, as long as it still follows the three rules above (notably, this
means there must be the same amount of events as the example).

In: UnderwaterBasketWeavingConvention 50 800 NSCC 500 550
Out: UnderwaterBasketWeavingConvention

In: SconeEating 0 50 RegexSubbing 45 110 CodeGolfing 95 105 NSCC 100 200
Out: SconeEating CodeGolfing

In: VelociraptorHunting 0 300 NerdSniping 200 500 SEChatting 400 700 DoorknobTurning 650 750 NSCC 725 775
Out: NerdSniping DoorknobTurning

In: NSCC 110 115 A 100 120 B 120 140 C 105 135 D 100 105 E 135 500
Out: C D E

In: A 800 900 NSCC 700 1000 B 650 750 C 950 1050 D 655 660 E 660 665 F 1030 1040 G 1040 1060
Out: A D E F G

In: A 10 11 B 11 12 C 12 13 D 13 14 NSCC 15 1090 E 10 16
Out: E

Feel free to add more test cases in an edit if there are edge-cases that I
missed.

Rules


Your code must complete within 30 seconds for all of the provided test cases
(this is more of a sanity check, as it should probably complete much faster
for all the test cases combined) on a reasonable personal machine.
This is code-golf, so the shortest code in bytes wins.
SWI-Prolog, 537 524 516 502 447 436 bytes
z(A:B:C,[D:E:F|G]):-(A=D;B&gt;=F;E&gt;=C),(G=[];z(A:B:C,G)).
u([A|B],C):-z(A,C),(B=[];u(B,C)).
y([A,B,C|D])--&gt;[A:B:C],(y(D);{_=_}).
d--&gt;[A:_],{write(A),tab(1)},d;{_=_}.
l([H|T],R):-T=[],R=H;length(H,N),l(T,X),length(X,M),(N&gt;M,R=H;R=X).
v([],_,R,R).
v([A|T],Z,B,R):-u(A,A),\+z(Z,A),v(T,Z,[A|B],R);v(T,Z,B,R).
s([E|T],[F|N]):-E=F,(N=[];s(T,N));s(T,[F|N]).
x(A):-y(A,D,[]),K=&quot;NSCC&quot;:_,select(K,D,E),setof(L,s(E,L),B),v(B,K,[],R),l(R,S),d(S,[]),!.

Brief explanation of what each predicate does:

z(A,B) checks that an event A doesn't conflict with any event of a list of events B
u(A,B) checks that every event of a list A does not conflict with any event of a list B (used to check that there are no conflicts in list A by calling u(A,A))
y(A,B,C) splits a List into a list of triplets (to transform inputs into a list of events)
d(A) prints the names of events in a list A
l(A,R) evaluates the longest list of events R contained in the list of lists A
v(A,NSCC,C,R) returns a list R containing every list of events in A that have no internal conflict and that conflict with the event NSCC
s(A,B) true if B is a subset of A
x(A) main predicate, A is the input.

Test cases: execute test. in the interpreter after loading the code above with the following added after it:
test:-
    x([&quot;UnderwaterBasketWeavingConvention&quot;,50,800,&quot;NSCC&quot;,500,550]),
    nl,
    x([&quot;SconeEating&quot;,0,50,&quot;RegexSubbing&quot;,45,110,&quot;CodeGolfing&quot;,95,105,&quot;NSCC&quot;,100,200]),
    nl,
    x([&quot;VelociraptorHunting&quot;,0,300,&quot;NerdSniping&quot;,200,500,&quot;SEChatting&quot;,400,700,&quot;DoorknobTurning&quot;,650,750,&quot;NSCC&quot;,725,775]),
    nl,
    x([&quot;NSCC&quot;,110,115,&quot;A&quot;,100,120,&quot;B&quot;,120,140,&quot;C&quot;,105,135,&quot;D&quot;,100,105,&quot;E&quot;,135,500]),
    nl,
    x([&quot;A&quot;,800,900,&quot;NSCC&quot;,700,1000,&quot;B&quot;,650,750,&quot;C&quot;,950,1050,&quot;D&quot;,655,660,&quot;E&quot;,660,665,&quot;F&quot;,1030,1040,&quot;G&quot;,1040,1060]),
    nl,
    x([&quot;A&quot;,10,11,&quot;B&quot;,11,12,&quot;C&quot;,12,13,&quot;D&quot;,13,14,&quot;NSCC&quot;,15,1090,&quot;E&quot;,10,16]).

This took me way more time than I thought it would. This can probably be golfed significantly more. Also you could probably use the various constraint programming libraries that exist to get shorter solutions.
Edit: Thanks to @Oliphaunt for the idea of using A:B:C instead of [A,B,C] for triplets. Saves 14 bytes.
Edit2: Thanks again to @Oliphaunt for  pointing out that the predicate ``t/3`was useless. Saves 55 bytes
Edit3: Gained 11 bytes using definitive clause grammar on predicates y and d.