Job Board

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