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