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