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