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

...we are embarking on a “vast, frightening experiment”, asking “how dangerous are we actually prepared to make our world?”
