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