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