Module Call Resolver

Problem Context

In legacy enterprise systems (like those built on COBOL), programs can invoke subprograms either statically (linked at compile time, always in memory) or dynamically (loaded at runtime, can be swapped without recompilation). Understanding the performance and memory trade-offs of these paradigms is critical when optimizing large batch systems.

You are simulating a simplified module call dispatcher that decides whether to use a static or dynamic call strategy for a list of subprogram invocations.

Given a list of subprogram calls with their call types and usage frequencies, compute the total execution cost under two strategies:

• STATIC CALL: The module is always loaded in memory. Each call costs 1 unit (no load overhead). However, memory reservation costs M units per unique static module regardless of call count.
• DYNAMIC CALL: The module is loaded on first use per session, then cached. First call to a unique module costs D units; subsequent calls to the same module cost 1 unit each.

Return the strategy ("STATIC" or "DYNAMIC") with the lower total cost. If costs are equal, return "STATIC".

Input Format

Your function receives:

• calls: a list of strings representing subprogram names in invocation order
• M: integer memory reservation cost per unique static module
• D: integer dynamic load cost for first invocation of a module

Output Format

Return a string: "STATIC" or "DYNAMIC"

Examples

Example 1

Input: calls = ["MOD-A", "MOD-B", "MOD-A", "MOD-A"], M = 5, D = 4

Output: "DYNAMIC"

Explanation:

• Static cost: 2 unique modules × M(5) + 4 calls × 1 = 10 + 4 = 14
• Dynamic cost: MOD-A first call D(4) + MOD-B first call D(4) + 2 repeat calls × 1 = 10
• Dynamic wins.

Example 2

Input: calls = ["MOD-X", "MOD-Y", "MOD-Z"], M = 2, D = 10

Output: "STATIC"

Explanation:

• Static cost: 3 unique × M(2) + 3 calls × 1 = 6 + 3 = 9
• Dynamic cost: 3 unique first calls × D(10) = 30
• Static wins.

Example 3