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