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