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