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