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