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