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