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