Startup Landing Page

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