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