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