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