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