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