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