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