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