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