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