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