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