Manager - Product Engineering
Hackajob
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