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