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