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