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