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