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