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