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