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