AI-Generated Meditation & Mindfulness Apps

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