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