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