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