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