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