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