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