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