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