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