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