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