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