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