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