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