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

“They will be offered new identities,” a senior Whitehall figure said.
