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